home *** CD-ROM | disk | FTP | other *** search
/ Micromanía 92 / CDMM92_1.ISO / SOF 2 SDK / sof2sdk-101.msi / _92D6AC311BB48EBA344BBABC89DA6AB0 / _EEBCC5FAFFBF41A5B8E08DB9BFCC1879 < prev    next >
Encoding:
Text File  |  2002-07-02  |  182.4 KB  |  7,671 lines
  1. // Copyright (C) 2001-2002 Raven Software.
  2. // 
  3. // string allocation/managment
  4.  
  5. #include "ui_shared.h"
  6. #include "../game/bg_public.h"
  7.  
  8. #define SCROLL_TIME_START                    500
  9. #define SCROLL_TIME_ADJUST                150
  10. #define SCROLL_TIME_ADJUSTOFFSET    40
  11. #define SCROLL_TIME_FLOOR                    20
  12.  
  13. typedef struct scrollInfo_s {
  14.     int nextScrollTime;
  15.     int nextAdjustTime;
  16.     int adjustValue;
  17.     int scrollKey;
  18.     float xStart;
  19.     float yStart;
  20.     itemDef_t *item;
  21.     qboolean scrollDir;
  22. } scrollInfo_t;
  23.  
  24. static scrollInfo_t scrollInfo;
  25.  
  26. static void (*captureFunc) (void *p) = NULL;
  27. static void *captureData = NULL;
  28. static itemDef_t *itemCapture = NULL;        // item that has the mouse captured ( if any )
  29. static itemDef_t *itemExclusive = NULL;        // item that has exclusive input (combo box)
  30.  
  31. displayContextDef_t *DC = NULL;
  32.  
  33. static qboolean g_waitingForKey = qfalse;
  34. static qboolean g_editingField = qfalse;
  35.  
  36. static itemDef_t *g_bindItem = NULL;
  37. static itemDef_t *g_editItem = NULL;
  38.  
  39. menuDef_t Menus[MAX_MENUS];      // defined menus
  40. int menuCount = 0;               // how many
  41.  
  42. menuDef_t *menuStack[MAX_OPEN_MENUS];
  43. int openMenuCount = 0;
  44.  
  45. static qboolean debugMode = qfalse;
  46.  
  47. #define DOUBLE_CLICK_DELAY 300
  48. static int lastListBoxClickTime = 0;
  49.  
  50. void Item_RunScript(itemDef_t *item, const char *s);
  51. void Item_SetupKeywordHash(void);
  52. void Menu_SetupKeywordHash(void);
  53. int BindingIDFromName(const char *name);
  54. qboolean Item_Bind_HandleKey(itemDef_t *item, int key, qboolean down);
  55. itemDef_t *Menu_SetPrevCursorItem(menuDef_t *menu);
  56. itemDef_t *Menu_SetNextCursorItem(menuDef_t *menu);
  57. static qboolean Menu_OverActiveItem(menuDef_t *menu, float x, float y);
  58. static void Item_TextScroll_BuildLines ( itemDef_t* item );
  59.  
  60. typedef struct  itemFlagsDef_s 
  61. {
  62.     char    *string;
  63.     int        value;
  64.  
  65. }    itemFlagsDef_t;
  66.  
  67. itemFlagsDef_t itemFlags [] = 
  68. {
  69.     "WINDOW_INACTIVE",        WINDOW_INACTIVE,
  70.     NULL,                    (int) NULL
  71. };
  72.  
  73. char *styles [] = 
  74. {
  75.     "WINDOW_STYLE_EMPTY",
  76.     "WINDOW_STYLE_FILLED",
  77.     "WINDOW_STYLE_SHADER",
  78.     "WINDOW_STYLE_CINEMATIC",
  79.     NULL
  80. };
  81.  
  82. char *alignment [] = 
  83. {
  84.     "ITEM_ALIGN_LEFT",
  85.     "ITEM_ALIGN_CENTER",
  86.     "ITEM_ALIGN_RIGHT",
  87.     NULL
  88. };
  89.  
  90. char *types [] = 
  91. {
  92.     "ITEM_TYPE_TEXT",
  93.     "ITEM_TYPE_BUTTON",
  94.     "ITEM_TYPE_RADIOBUTTON",
  95.     "ITEM_TYPE_CHECKBOX",
  96.     "ITEM_TYPE_EDITFIELD",
  97.     "ITEM_TYPE_COMBO",
  98.     "ITEM_TYPE_LISTBOX",
  99.     "ITEM_TYPE_OWNERDRAW",
  100.     "ITEM_TYPE_MODEL",
  101.     "ITEM_TYPE_NUMERICFIELD",
  102.     "ITEM_TYPE_SLIDER",
  103.     "ITEM_TYPE_YESNO",
  104.     "ITEM_TYPE_MULTI",
  105.     "ITEM_TYPE_BIND",
  106.     "ITEM_TYPE_PASSWORDFIELD",
  107.     "ITEM_TYPE_COMBOBOX",
  108.     "ITEM_TYPE_TEXTSCROLL",
  109.     NULL
  110. };
  111.  
  112. #if !(CGAME)
  113.     extern vmCvar_t    ui_allowparental;
  114. #endif
  115.  
  116. #define HASH_TABLE_SIZE 2048
  117.  
  118. /*
  119. ================
  120. return a hash value for the string
  121. ================
  122. */
  123. static long hashForString(const char *str) {
  124.     int        i;
  125.     long    hash;
  126.     char    letter;
  127.  
  128.     hash = 0;
  129.     i = 0;
  130.     while (str[i] != '\0') {
  131.         letter = tolower(str[i]);
  132.         hash+=(long)(letter)*(i+119);
  133.         i++;
  134.     }
  135.     hash &= (HASH_TABLE_SIZE-1);
  136.     return hash;
  137. }
  138.  
  139. typedef struct stringDef_s {
  140.     struct stringDef_s *next;
  141.     const char *str;
  142. } stringDef_t;
  143.  
  144. static int strPoolIndex = 0;
  145. static char strPool[STRING_POOL_SIZE];
  146.  
  147. static int strHandleCount = 0;
  148. static stringDef_t *strHandle[HASH_TABLE_SIZE];
  149.  
  150.  
  151. const char *String_Alloc(const char *p) {
  152.     int len;
  153.     long hash;
  154.     stringDef_t *str, *last;
  155.     static const char *staticNULL = "";
  156.  
  157.     if (p == NULL) {
  158.         return NULL;
  159.     }
  160.  
  161.     if (*p == 0) {
  162.         return staticNULL;
  163.     }
  164.  
  165.     hash = hashForString(p);
  166.  
  167.     str = strHandle[hash];
  168.     while (str) {
  169.         if (strcmp(p, str->str) == 0) {
  170.             return str->str;
  171.         }
  172.         str = str->next;
  173.     }
  174.  
  175.     len = strlen(p);
  176.     if (len + strPoolIndex + 1 < STRING_POOL_SIZE) {
  177.         int ph = strPoolIndex;
  178.         strcpy(&strPool[strPoolIndex], p);
  179.         strPoolIndex += len + 1;
  180.  
  181.         str = strHandle[hash];
  182.         last = str;
  183.         while (str && str->next) {
  184.             last = str;
  185.             str = str->next;
  186.         }
  187.  
  188.         str  = trap_VM_LocalAlloc(sizeof(stringDef_t));
  189.         str->next = NULL;
  190.         str->str = &strPool[ph];
  191.         if (last) {
  192.             last->next = str;
  193.         } else {
  194.             strHandle[hash] = str;
  195.         }
  196.         return &strPool[ph];
  197.     }
  198.     return NULL;
  199. }
  200.  
  201. void String_Report() {
  202.     float f;
  203.     Com_Printf("Memory/String Pool Info\n");
  204.     Com_Printf("----------------\n");
  205.     f = strPoolIndex;
  206.     f /= STRING_POOL_SIZE;
  207.     f *= 100;
  208.     Com_Printf("String Pool is %.1f%% full, %i bytes out of %i used.\n", f, strPoolIndex, STRING_POOL_SIZE);
  209. }
  210.  
  211. /*
  212. =================
  213. String_Init
  214. =================
  215. */
  216. void String_Init() {
  217.     int i;
  218.     for (i = 0; i < HASH_TABLE_SIZE; i++) {
  219.         strHandle[i] = 0;
  220.     }
  221.     strHandleCount = 0;
  222.     strPoolIndex = 0;
  223.     menuCount = 0;
  224.     openMenuCount = 0;
  225.     Item_SetupKeywordHash();
  226.     Menu_SetupKeywordHash();
  227.     if (DC && DC->getBindingBuf) {
  228.         Controls_GetConfig();
  229.     }
  230. }
  231.  
  232. /*
  233. =================
  234. PC_SourceWarning
  235. =================
  236. */
  237. void PC_SourceWarning(int handle, char *format, ...) 
  238. {
  239.     int line;
  240.     char filename[128];
  241.     va_list argptr;
  242.     static char string[4096];
  243.  
  244.     va_start (argptr, format);
  245.     vsprintf (string, format, argptr);
  246.     va_end (argptr);
  247.  
  248.     filename[0] = '\0';
  249.     line = 0;
  250.     trap_PC_SourceFileAndLine(handle, filename, &line);
  251.  
  252.     Com_Printf(S_COLOR_YELLOW "WARNING: %s, line %d: %s\n", filename, line, string);
  253. }
  254.  
  255. /*
  256. =================
  257. PC_SourceError
  258. =================
  259. */
  260. void PC_SourceError(int handle, char *format, ...) {
  261.     int line;
  262.     char filename[128];
  263.     va_list argptr;
  264.     static char string[4096];
  265.  
  266.     va_start (argptr, format);
  267.     vsprintf (string, format, argptr);
  268.     va_end (argptr);
  269.  
  270.     filename[0] = '\0';
  271.     line = 0;
  272.     trap_PC_SourceFileAndLine(handle, filename, &line);
  273.  
  274.     Com_Printf(S_COLOR_RED "ERROR: %s, line %d: %s\n", filename, line, string);
  275. }
  276.  
  277. /*
  278. =================
  279. LerpColor
  280. =================
  281. */
  282. void LerpColor(vec4_t a, vec4_t b, vec4_t c, float t)
  283. {
  284.     int i;
  285.  
  286.     // lerp and clamp each component
  287.     for (i=0; i<4; i++)
  288.     {
  289.         c[i] = a[i] + t*(b[i]-a[i]);
  290.         if (c[i] < 0)
  291.             c[i] = 0;
  292.         else if (c[i] > 1.0)
  293.             c[i] = 1.0;
  294.     }
  295. }
  296.  
  297. /*
  298. =================
  299. Float_Parse
  300. =================
  301. */
  302. qboolean Float_Parse(const char **p, float *f) {
  303.     char    *token;
  304.     token = COM_ParseExt(p, qfalse);
  305.     if (token && token[0] != 0) {
  306.         *f = atof(token);
  307.         return qtrue;
  308.     } else {
  309.         return qfalse;
  310.     }
  311. }
  312.  
  313. /*
  314. =================
  315. PC_Float_Parse
  316. =================
  317. */
  318. qboolean PC_Float_Parse(int handle, float *f) {
  319.     pc_token_t token;
  320.     int negative = qfalse;
  321.  
  322.     if (!trap_PC_ReadToken(handle, &token))
  323.         return qfalse;
  324.     if (token.string[0] == '-') {
  325.         if (!trap_PC_ReadToken(handle, &token))
  326.             return qfalse;
  327.         negative = qtrue;
  328.     }
  329.     if (token.type != TT_NUMBER) {
  330.         PC_SourceError(handle, "expected float but found %s\n", token.string);
  331.         return qfalse;
  332.     }
  333.     if (negative)
  334.         *f = -token.floatvalue;
  335.     else
  336.         *f = token.floatvalue;
  337.     return qtrue;
  338. }
  339.  
  340. /*
  341. =================
  342. Color_Parse
  343. =================
  344. */
  345. qboolean Color_Parse(const char **p, vec4_t *c) {
  346.     int i;
  347.     float f;
  348.  
  349.     for (i = 0; i < 4; i++) {
  350.         if (!Float_Parse(p, &f)) {
  351.             return qfalse;
  352.         }
  353.         (*c)[i] = f;
  354.     }
  355.     return qtrue;
  356. }
  357.  
  358. /*
  359. =================
  360. PC_Color_Parse
  361. =================
  362. */
  363. qboolean PC_Color_Parse(int handle, vec4_t *c) {
  364.     int i;
  365.     float f;
  366.  
  367.     for (i = 0; i < 4; i++) {
  368.         if (!PC_Float_Parse(handle, &f)) {
  369.             return qfalse;
  370.         }
  371.         (*c)[i] = f;
  372.     }
  373.     return qtrue;
  374. }
  375.  
  376. /*
  377. =================
  378. Int_Parse
  379. =================
  380. */
  381. qboolean Int_Parse(const char **p, int *i) {
  382.     char    *token;
  383.     token = COM_ParseExt(p, qfalse);
  384.  
  385.     if (token && token[0] != 0) {
  386.         *i = atoi(token);
  387.         return qtrue;
  388.     } else {
  389.         return qfalse;
  390.     }
  391. }
  392.  
  393. /*
  394. =================
  395. PC_Int_Parse
  396. =================
  397. */
  398. qboolean PC_Int_Parse(int handle, int *i) {
  399.     pc_token_t token;
  400.     int negative = qfalse;
  401.  
  402.     if (!trap_PC_ReadToken(handle, &token))
  403.         return qfalse;
  404.     if (token.string[0] == '-') {
  405.         if (!trap_PC_ReadToken(handle, &token))
  406.             return qfalse;
  407.         negative = qtrue;
  408.     }
  409.     if (token.type != TT_NUMBER) {
  410.         PC_SourceError(handle, "expected integer but found %s\n", token.string);
  411.         return qfalse;
  412.     }
  413.     *i = token.intvalue;
  414.     if (negative)
  415.         *i = - *i;
  416.     return qtrue;
  417. }
  418.  
  419. /*
  420. =================
  421. Rect_Parse
  422. =================
  423. */
  424. qboolean Rect_Parse(const char **p, rectDef_t *r) {
  425.     if (Float_Parse(p, &r->x)) {
  426.         if (Float_Parse(p, &r->y)) {
  427.             if (Float_Parse(p, &r->w)) {
  428.                 if (Float_Parse(p, &r->h)) {
  429.                     return qtrue;
  430.                 }
  431.             }
  432.         }
  433.     }
  434.     return qfalse;
  435. }
  436.  
  437. /*
  438. =================
  439. PC_Rect_Parse
  440. =================
  441. */
  442. qboolean PC_Rect_Parse(int handle, rectDef_t *r) {
  443.     if (PC_Float_Parse(handle, &r->x)) {
  444.         if (PC_Float_Parse(handle, &r->y)) {
  445.             if (PC_Float_Parse(handle, &r->w)) {
  446.                 if (PC_Float_Parse(handle, &r->h)) {
  447.                     return qtrue;
  448.                 }
  449.             }
  450.         }
  451.     }
  452.     return qfalse;
  453. }
  454.  
  455. /*
  456. =================
  457. String_Parse
  458. =================
  459. */
  460. qboolean String_Parse(const char **p, const char **out) {
  461.     char *token;
  462.  
  463.     token = COM_ParseExt(p, qfalse);
  464.     if (token && token[0] != 0) {
  465.         *(out) = String_Alloc(token);
  466.         return qtrue;
  467.     }
  468.     return qfalse;
  469. }
  470.  
  471. /*
  472. =================
  473. PC_String_Parse
  474. =================
  475. */
  476. qboolean PC_String_Parse(int handle, const char **out) 
  477. {
  478.     pc_token_t token;
  479.  
  480.     if (!trap_PC_ReadToken(handle, &token))
  481.     {
  482.         return qfalse;
  483.     }
  484.  
  485.     *(out) = String_Alloc(token.string);
  486.     return qtrue;
  487. }
  488.  
  489. /*
  490. =================
  491. PC_Script_Parse
  492. =================
  493. */
  494. qboolean PC_Script_Parse(int handle, const char **out) {
  495.     char script[1024];
  496.     pc_token_t token;
  497.  
  498.     memset(script, 0, sizeof(script));
  499.     // scripts start with { and have ; separated command lists.. commands are command, arg.. 
  500.     // basically we want everything between the { } as it will be interpreted at run time
  501.   
  502.     if (!trap_PC_ReadToken(handle, &token))
  503.         return qfalse;
  504.     if (Q_stricmp(token.string, "{") != 0) {
  505.         return qfalse;
  506.     }
  507.  
  508.     while ( 1 ) {
  509.         if (!trap_PC_ReadToken(handle, &token))
  510.             return qfalse;
  511.  
  512.         if (Q_stricmp(token.string, "}") == 0) {
  513.             *out = String_Alloc(script);
  514.             return qtrue;
  515.         }
  516.  
  517.         if (token.string[1] != '\0') {
  518.             Q_strcat(script, 1024, va("\"%s\"", token.string));
  519.         } else {
  520.             Q_strcat(script, 1024, token.string);
  521.         }
  522.         Q_strcat(script, 1024, " ");
  523.     }
  524.     return qfalse;     // bk001105 - LCC   missing return value
  525. }
  526.  
  527. /*
  528. ==================
  529. Init_Display
  530.  
  531. Initializes the display with a structure to all the drawing routines
  532.  ==================
  533. */
  534. void Init_Display(displayContextDef_t *dc) 
  535. {
  536.     DC = dc;
  537. }
  538.  
  539. /*
  540. ==================
  541. Window_Init
  542.  
  543. Initializes a window structure ( windowDef_t ) with defaults
  544. ==================
  545. */
  546. void Window_Init(Window *w) {
  547.     memset(w, 0, sizeof(windowDef_t));
  548.     w->borderSize = 1;
  549.     w->foreColor[0] = w->foreColor[1] = w->foreColor[2] = w->foreColor[3] = 1.0;
  550.     w->cinematic = -1;
  551. }
  552.  
  553. void Fade(int *flags, float *f, float clamp, int *nextTime, int offsetTime, qboolean bFlags, float fadeAmount) {
  554.   if (*flags & (WINDOW_FADINGOUT | WINDOW_FADINGIN)) {
  555.     if (DC->realTime > *nextTime) {
  556.       *nextTime = DC->realTime + offsetTime;
  557.       if (*flags & WINDOW_FADINGOUT) {
  558.         *f -= fadeAmount;
  559.         if (bFlags && *f <= 0.0) {
  560.           *flags &= ~(WINDOW_FADINGOUT | WINDOW_VISIBLE);
  561.         }
  562.       } else {
  563.         *f += fadeAmount;
  564.         if (*f >= clamp) {
  565.           *f = clamp;
  566.           if (bFlags) {
  567.             *flags &= ~WINDOW_FADINGIN;
  568.           }
  569.         }
  570.       }
  571.     }
  572.   }
  573. }
  574.  
  575.  
  576. void Item_SetMouseOver(itemDef_t *item, qboolean focus) {
  577.   if (item) {
  578.     if (focus) {
  579.       item->window.flags |= WINDOW_MOUSEOVER;
  580.     } else {
  581.       item->window.flags &= ~WINDOW_MOUSEOVER;
  582.     }
  583.   }
  584.  
  585.     // Save the item that the mouse is over
  586.     if ( item->tooltip )
  587.     {
  588.         if ( focus )
  589.         {
  590.             DC->tooltipItem = item;
  591.         }
  592.         else if ( DC->tooltipItem == item )
  593.         {
  594.             DC->tooltipItem = NULL;
  595.         }
  596.     }
  597. }
  598.  
  599. void Window_Paint(Window *w, float fadeAmount, float fadeClamp, float fadeCycle) 
  600. {
  601.     vec4_t        color;
  602.     rectDef_t    fillRect;
  603.  
  604.     fillRect = w->rect;
  605.  
  606.     if (debugMode) 
  607.     {
  608.         color[0] = color[1] = color[2] = color[3] = 1;
  609.         DC->drawRect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, 1, color);
  610.     }
  611.  
  612.     if (w == NULL || (w->style == 0 && w->border == 0)) 
  613.     {
  614.         return;
  615.     }
  616.  
  617.     if (w->border != 0) 
  618.     {
  619.         fillRect.x += w->borderSize;
  620.         fillRect.y += w->borderSize;
  621.         fillRect.w -= w->borderSize + 1;
  622.         fillRect.h -= w->borderSize + 1;
  623.     }
  624.  
  625.     if (w->style == WINDOW_STYLE_FILLED) 
  626.     {
  627.         // box, but possible a shader that needs filled
  628.         if (w->background) 
  629.         {
  630.             Fade(&w->flags, &w->backColor[3], fadeClamp, &w->nextTime, fadeCycle, qtrue, fadeAmount);
  631.             DC->setColor(w->backColor);
  632.             DC->drawHandlePic(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->background);
  633.             DC->setColor(NULL);
  634.         } 
  635.         else 
  636.         {
  637.             DC->fillRect(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->backColor);
  638.         }
  639.     } 
  640.     else if (w->style == WINDOW_STYLE_SHADER) 
  641.     {
  642.         if (w->flags & WINDOW_FORECOLORSET) 
  643.         {
  644.             DC->setColor(w->foreColor);
  645.         }
  646.         DC->drawHandlePic(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->background);
  647.         DC->setColor(NULL);
  648.     } 
  649.     else if (w->style == WINDOW_STYLE_CINEMATIC) 
  650.     {
  651.         if (w->cinematic == -1) 
  652.         {
  653.             w->cinematic = DC->playCinematic(w->cinematicName, fillRect.x, fillRect.y, fillRect.w, fillRect.h);
  654.             if (w->cinematic == -1) 
  655.             {
  656.                 w->cinematic = -2;
  657.             }
  658.         } 
  659.         if (w->cinematic >= 0) 
  660.         {
  661.             DC->runCinematicFrame(w->cinematic);
  662.             DC->drawCinematic(w->cinematic, fillRect.x, fillRect.y, fillRect.w, fillRect.h);
  663.         }
  664.     }
  665.  
  666.     if (w->border == WINDOW_BORDER_FULL) 
  667.     {
  668.         DC->drawRect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize, w->borderColor);
  669.     } 
  670.     else if (w->border == WINDOW_BORDER_HORZ) 
  671.     {
  672.         // top/bottom
  673.         DC->setColor(w->borderColor);
  674.         DC->drawTopBottom(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize);
  675.         DC->setColor( NULL );
  676.     } 
  677.     else if (w->border == WINDOW_BORDER_VERT) 
  678.     {
  679.         // left right
  680.         DC->setColor(w->borderColor);
  681.         DC->drawSides(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize);
  682.         DC->setColor( NULL );
  683.     } 
  684. }
  685.  
  686.  
  687. void Item_SetScreenCoords(itemDef_t *item, float x, float y) 
  688. { 
  689.     if (item == NULL) 
  690.     {
  691.         return;
  692.     }
  693.  
  694.     if (item->window.border != 0) 
  695.     {
  696.         x += item->window.borderSize;
  697.         y += item->window.borderSize;
  698.     }
  699.  
  700.     item->window.rect.x = x + item->window.rectClient.x;
  701.     item->window.rect.y = y + item->window.rectClient.y;
  702.     item->window.rect.w = item->window.rectClient.w;
  703.     item->window.rect.h = item->window.rectClient.h;
  704.  
  705.     // force the text rects to recompute
  706.     item->textRect.w = 0;
  707.     item->textRect.h = 0;
  708.  
  709.     switch ( item->type )
  710.     {
  711.         case ITEM_TYPE_COMBOBOX:
  712.         {
  713.             listBoxDef_t* listPtr = (listBoxDef_t*) item->typeData;
  714.  
  715.             listPtr->comboRect = item->window.rect;
  716.             listPtr->comboRect.h = listPtr->elementHeight;
  717.  
  718.             if ( !(item->window.flags & WINDOW_DROPPED ) )
  719.             {
  720.                 item->window.rect.h = listPtr->elementHeight;
  721.             }
  722.  
  723.             listPtr->listRect = item->window.rect;
  724.             listPtr->listRect.y += (listPtr->elementHeight + item->window.border);
  725.             listPtr->listRect.h -= (listPtr->elementHeight + item->window.border);
  726.             
  727.             break;
  728.         }
  729.  
  730.         case ITEM_TYPE_LISTBOX:
  731.         {
  732.             listBoxDef_t* listPtr = (listBoxDef_t*) item->typeData;
  733.             listPtr->listRect = item->window.rect;
  734.             break;
  735.         }
  736.  
  737.         case ITEM_TYPE_TEXTSCROLL:
  738.         {
  739.             textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
  740.             if ( scrollPtr )
  741.             {
  742.                 scrollPtr->startPos = 0;
  743.                 scrollPtr->endPos = 0;
  744.             }
  745.  
  746.             Item_TextScroll_BuildLines ( item );
  747.  
  748.             break;
  749.         }
  750.     }    
  751. }
  752.  
  753. // FIXME: consolidate this with nearby stuff
  754. void Item_UpdatePosition(itemDef_t *item) 
  755. {
  756.     float x, y;
  757.     menuDef_t *menu;
  758.   
  759.     if (item == NULL || item->parent == NULL) 
  760.     {
  761.         return;
  762.     }
  763.  
  764.     menu = item->parent;
  765.  
  766.     x = menu->window.rect.x;
  767.     y = menu->window.rect.y;
  768.   
  769.     if (menu->window.border != 0) 
  770.     {
  771.         x += menu->window.borderSize;
  772.         y += menu->window.borderSize;
  773.     }
  774.  
  775.     Item_SetScreenCoords(item, x, y);
  776. }
  777.  
  778. // menus
  779. void Menu_UpdatePosition(menuDef_t *menu) 
  780. {
  781.     int      i;
  782.     float x;
  783.     float y;
  784.  
  785.     if (menu == NULL) 
  786.     {
  787.         return;
  788.     }
  789.   
  790.     x = menu->window.rect.x;
  791.     y = menu->window.rect.y;
  792.     
  793.     if (menu->window.border != 0) 
  794.     {
  795.         x += menu->window.borderSize;
  796.         y += menu->window.borderSize;
  797.     }
  798.  
  799.     for (i = 0; i < menu->itemCount; i++) 
  800.     {
  801.         Item_SetScreenCoords(menu->items[i], x, y);
  802.     }
  803. }
  804.  
  805. void Menu_PostParse(menuDef_t *menu) 
  806. {
  807.     if (menu == NULL) 
  808.     {
  809.         return;
  810.     }
  811.  
  812.     if (menu->fullScreen) 
  813.     {
  814.         menu->window.rect.x = 0;
  815.         menu->window.rect.y = 0;
  816.         menu->window.rect.w = 640;
  817.         menu->window.rect.h = 480;
  818.     }
  819.  
  820.     Menu_UpdatePosition(menu);
  821. }
  822.  
  823. itemDef_t *Menu_ClearFocus(menuDef_t *menu) {
  824.   int i;
  825.   itemDef_t *ret = NULL;
  826.  
  827.   if (menu == NULL) {
  828.     return NULL;
  829.   }
  830.  
  831.   for (i = 0; i < menu->itemCount; i++) {
  832.     if (menu->items[i]->window.flags & WINDOW_HASFOCUS) {
  833.       ret = menu->items[i];
  834.     } 
  835.     menu->items[i]->window.flags &= ~WINDOW_HASFOCUS;
  836.     if (menu->items[i]->leaveFocus) {
  837.       Item_RunScript(menu->items[i], menu->items[i]->leaveFocus);
  838.     }
  839.   }
  840.  
  841.   return ret;
  842. }
  843.  
  844. qboolean IsVisible(int flags) {
  845.   return (flags & WINDOW_VISIBLE && !(flags & WINDOW_FADINGOUT));
  846. }
  847.  
  848. qboolean Rect_ContainsPoint(rectDef_t *rect, float x, float y) {
  849.   if (rect) {
  850.     if (x > rect->x && x < rect->x + rect->w && y > rect->y && y < rect->y + rect->h) {
  851.       return qtrue;
  852.     }
  853.   }
  854.   return qfalse;
  855. }
  856.  
  857. int Menu_ItemsMatchingGroup(menuDef_t *menu, const char *name) {
  858.   int i;
  859.   int count = 0;
  860.   for (i = 0; i < menu->itemCount; i++) {
  861.     if (Q_stricmp(menu->items[i]->window.name, name) == 0 || (menu->items[i]->window.group && Q_stricmp(menu->items[i]->window.group, name) == 0)) {
  862.       count++;
  863.     } 
  864.   }
  865.   return count;
  866. }
  867.  
  868. itemDef_t *Menu_GetMatchingItemByNumber(menuDef_t *menu, int index, const char *name) {
  869.   int i;
  870.   int count = 0;
  871.   for (i = 0; i < menu->itemCount; i++) {
  872.     if (Q_stricmp(menu->items[i]->window.name, name) == 0 || (menu->items[i]->window.group && Q_stricmp(menu->items[i]->window.group, name) == 0)) {
  873.       if (count == index) {
  874.         return menu->items[i];
  875.       }
  876.       count++;
  877.     } 
  878.   }
  879.   return NULL;
  880. }
  881.  
  882.  
  883.  
  884. void Script_SetColor(itemDef_t *item, const char **args) {
  885.   const char *name;
  886.   int i;
  887.   float f;
  888.   vec4_t *out;
  889.   // expecting type of color to set and 4 args for the color
  890.   if (String_Parse(args, &name)) {
  891.       out = NULL;
  892.       if (Q_stricmp(name, "backcolor") == 0) {
  893.         out = &item->window.backColor;
  894.         item->window.flags |= WINDOW_BACKCOLORSET;
  895.       } else if (Q_stricmp(name, "forecolor") == 0) {
  896.         out = &item->window.foreColor;
  897.         item->window.flags |= WINDOW_FORECOLORSET;
  898.       } else if (Q_stricmp(name, "bordercolor") == 0) {
  899.         out = &item->window.borderColor;
  900.       }
  901.  
  902.       if (out) {
  903.         for (i = 0; i < 4; i++) {
  904.           if (!Float_Parse(args, &f)) {
  905.             return;
  906.           }
  907.           (*out)[i] = f;
  908.         }
  909.       }
  910.   }
  911. }
  912.  
  913. void Script_SetAsset(itemDef_t *item, const char **args) {
  914.   const char *name;
  915.   // expecting name to set asset to
  916.   if (String_Parse(args, &name)) {
  917.     // check for a model 
  918.     if (item->type == ITEM_TYPE_MODEL) {
  919.     }
  920.   }
  921. }
  922.  
  923. void Script_SetMenuBackground ( itemDef_t* item, const char **args)
  924. {
  925.     const char* name;
  926.  
  927.     // expecting name to set asset to
  928.     if (String_Parse(args, &name)) 
  929.     {
  930.         if ( item->parent )
  931.         {
  932.             menuDef_t* menu = (menuDef_t*)item->parent;
  933.             menu->window.background = DC->registerShaderNoMip(name);
  934.         }
  935.     }
  936. }
  937.  
  938.  
  939. void Script_SetBackground(itemDef_t *item, const char **args) 
  940. {
  941.     const char *name;
  942.  
  943.     // expecting name to set asset to
  944.     if (String_Parse(args, &name)) 
  945.     {
  946.         item->window.background = DC->registerShaderNoMip(name);
  947.     }
  948. }
  949.  
  950.  
  951.  
  952.  
  953. itemDef_t *Menu_FindItemByName(menuDef_t *menu, const char *p) {
  954.   int i;
  955.   if (menu == NULL || p == NULL) {
  956.     return NULL;
  957.   }
  958.  
  959.   for (i = 0; i < menu->itemCount; i++) {
  960.     if (Q_stricmp(p, menu->items[i]->window.name) == 0) {
  961.       return menu->items[i];
  962.     }
  963.   }
  964.  
  965.   return NULL;
  966. }
  967.  
  968. void Script_SetTeamColor(itemDef_t *item, const char **args) {
  969.   if (DC->getTeamColor) {
  970.     int i;
  971.     vec4_t color;
  972.     DC->getTeamColor(&color);
  973.     for (i = 0; i < 4; i++) {
  974.       item->window.backColor[i] = color[i];
  975.     }
  976.   }
  977. }
  978.  
  979. void Script_SetItemColor(itemDef_t *item, const char **args) {
  980.   const char *itemname;
  981.   const char *name;
  982.   vec4_t color;
  983.   int i;
  984.   vec4_t *out;
  985.   // expecting type of color to set and 4 args for the color
  986.   if (String_Parse(args, &itemname) && String_Parse(args, &name)) {
  987.     itemDef_t *item2;
  988.     int j;
  989.     int count = Menu_ItemsMatchingGroup(item->parent, itemname);
  990.  
  991.     if (!Color_Parse(args, &color)) {
  992.       return;
  993.     }
  994.  
  995.     for (j = 0; j < count; j++) {
  996.       item2 = Menu_GetMatchingItemByNumber(item->parent, j, itemname);
  997.       if (item2 != NULL) {
  998.         out = NULL;
  999.         if (Q_stricmp(name, "backcolor") == 0) {
  1000.           out = &item2->window.backColor;
  1001.         } else if (Q_stricmp(name, "forecolor") == 0) {
  1002.           out = &item2->window.foreColor;
  1003.           item2->window.flags |= WINDOW_FORECOLORSET;
  1004.         } else if (Q_stricmp(name, "bordercolor") == 0) {
  1005.           out = &item2->window.borderColor;
  1006.         }
  1007.  
  1008.         if (out) {
  1009.           for (i = 0; i < 4; i++) {
  1010.             (*out)[i] = color[i];
  1011.           }
  1012.         }
  1013.       }
  1014.     }
  1015.   }
  1016. }
  1017.  
  1018.  
  1019. void Menu_ShowItemByName(menuDef_t *menu, const char *p, qboolean bShow) {
  1020.     itemDef_t *item;
  1021.     int i;
  1022.     int count = Menu_ItemsMatchingGroup(menu, p);
  1023.     for (i = 0; i < count; i++) {
  1024.         item = Menu_GetMatchingItemByNumber(menu, i, p);
  1025.         if (item != NULL) {
  1026.             if (bShow) {
  1027.                 item->window.flags |= WINDOW_VISIBLE;
  1028.             } else {
  1029.                 item->window.flags &= ~WINDOW_VISIBLE;
  1030.                 // stop cinematics playing in the window
  1031.                 if (item->window.cinematic >= 0) {
  1032.                     DC->stopCinematic(item->window.cinematic);
  1033.                     item->window.cinematic = -1;
  1034.                 }
  1035.  
  1036.                 if ( DC->tooltipItem == item )
  1037.                     DC->tooltipItem = NULL;
  1038.             }
  1039.         }
  1040.     }
  1041. }
  1042.  
  1043. void Menu_FadeItemByName(menuDef_t *menu, const char *p, qboolean fadeOut) {
  1044.   itemDef_t *item;
  1045.   int i;
  1046.   int count = Menu_ItemsMatchingGroup(menu, p);
  1047.   for (i = 0; i < count; i++) {
  1048.     item = Menu_GetMatchingItemByNumber(menu, i, p);
  1049.     if (item != NULL) {
  1050.       if (fadeOut) {
  1051.         item->window.flags |= (WINDOW_FADINGOUT | WINDOW_VISIBLE);
  1052.         item->window.flags &= ~WINDOW_FADINGIN;
  1053.       } else {
  1054.         item->window.flags |= (WINDOW_VISIBLE | WINDOW_FADINGIN);
  1055.         item->window.flags &= ~WINDOW_FADINGOUT;
  1056.       }
  1057.     }
  1058.   }
  1059. }
  1060.  
  1061. menuDef_t *Menus_FindByName(const char *p) {
  1062.   int i;
  1063.   for (i = 0; i < menuCount; i++) {
  1064.     if (Q_stricmp(Menus[i].window.name, p) == 0) {
  1065.       return &Menus[i];
  1066.     } 
  1067.   }
  1068.   return NULL;
  1069. }
  1070.  
  1071. void Menus_ShowByName(const char *p) {
  1072.     menuDef_t *menu = Menus_FindByName(p);
  1073.     if (menu) {
  1074.         Menus_Activate(menu);
  1075.     }
  1076. }
  1077.  
  1078. void Menus_OpenByName(const char *p) {
  1079.   Menus_ActivateByName(p);
  1080. }
  1081.  
  1082. static void Menu_RunCloseScript(menuDef_t *menu) {
  1083.     if (menu && (menu->window.flags & WINDOW_VISIBLE) && menu->onClose) {
  1084.         itemDef_t item;
  1085.     item.parent = menu;
  1086.     Item_RunScript(&item, menu->onClose);
  1087.     }
  1088. }
  1089.  
  1090. void Menus_CloseByName(const char *p) 
  1091. {
  1092.     menuDef_t *menu = Menus_FindByName(p);
  1093.     
  1094.     // If the menu wasnt found just exit
  1095.     if (menu == NULL) 
  1096.     {
  1097.         return;
  1098.     }
  1099.  
  1100.     // Run the close script for the menu
  1101.     Menu_RunCloseScript(menu);
  1102.  
  1103.     // If this window had the focus then take it away
  1104.     if ( menu->window.flags & WINDOW_HASFOCUS )
  1105.     {    
  1106.         // If there is something still in the open menu list then
  1107.         // set it to have focus now
  1108.         if ( openMenuCount )
  1109.         {
  1110.             // Subtract one from the open menu count to prepare to
  1111.             // remove the top menu from the list
  1112.             openMenuCount -= 1;
  1113.  
  1114.             // Set the top menu to have focus now
  1115.             menuStack[openMenuCount]->window.flags |= WINDOW_HASFOCUS;
  1116.  
  1117.             // Remove the top menu from the list
  1118.             menuStack[openMenuCount] = NULL;
  1119.         }
  1120.     }
  1121.  
  1122.     // Window is now invisible and doenst have focus
  1123.     menu->window.flags &= ~(WINDOW_VISIBLE | WINDOW_HASFOCUS);
  1124. }
  1125.  
  1126. void Menus_CloseAll() 
  1127. {
  1128.     int i;
  1129.  
  1130.     itemExclusive = NULL;
  1131.     itemCapture = NULL;
  1132.  
  1133.     g_waitingForKey = qfalse;
  1134.  
  1135.     for (i = 0; i < menuCount; i++) 
  1136.     {
  1137.         Menu_RunCloseScript ( &Menus[i] );
  1138.         Menus[i].window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
  1139.     }
  1140.  
  1141.     // Clear the menu stack
  1142.     openMenuCount = 0;
  1143. }
  1144.  
  1145. void Script_Show(itemDef_t *item, const char **args) {
  1146.   const char *name;
  1147.   if (String_Parse(args, &name)) {
  1148.     Menu_ShowItemByName(item->parent, name, qtrue);
  1149.   }
  1150. }
  1151.  
  1152. void Script_Hide(itemDef_t *item, const char **args) {
  1153.   const char *name;
  1154.   if (String_Parse(args, &name)) {
  1155.     Menu_ShowItemByName(item->parent, name, qfalse);
  1156.   }
  1157. }
  1158.  
  1159. void Script_FadeIn(itemDef_t *item, const char **args) {
  1160.   const char *name;
  1161.   if (String_Parse(args, &name)) {
  1162.     Menu_FadeItemByName(item->parent, name, qfalse);
  1163.   }
  1164. }
  1165.  
  1166. void Script_FadeOut(itemDef_t *item, const char **args) {
  1167.   const char *name;
  1168.   if (String_Parse(args, &name)) {
  1169.     Menu_FadeItemByName(item->parent, name, qtrue);
  1170.   }
  1171. }
  1172.  
  1173.  
  1174.  
  1175. void Script_Open(itemDef_t *item, const char **args) {
  1176.   const char *name;
  1177.   if (String_Parse(args, &name)) {
  1178.     Menus_OpenByName(name);
  1179.   }
  1180. }
  1181.  
  1182. void Script_Close(itemDef_t *item, const char **args) {
  1183.   const char *name;
  1184.   if (String_Parse(args, &name)) {
  1185.     Menus_CloseByName(name);
  1186.   }
  1187. }
  1188.  
  1189. void Menu_TransitionItemByName(menuDef_t *menu, const char *p, rectDef_t rectFrom, rectDef_t rectTo, int time, float amt) {
  1190.   itemDef_t *item;
  1191.   int i;
  1192.   int count = Menu_ItemsMatchingGroup(menu, p);
  1193.   for (i = 0; i < count; i++) {
  1194.     item = Menu_GetMatchingItemByNumber(menu, i, p);
  1195.     if (item != NULL) {
  1196.       item->window.flags |= (WINDOW_INTRANSITION | WINDOW_VISIBLE);
  1197.       item->window.offsetTime = time;
  1198.             memcpy(&item->window.rectClient, &rectFrom, sizeof(rectDef_t));
  1199.             memcpy(&item->window.rectEffects, &rectTo, sizeof(rectDef_t));
  1200.             item->window.rectEffects2.x = abs(rectTo.x - rectFrom.x) / amt;
  1201.             item->window.rectEffects2.y = abs(rectTo.y - rectFrom.y) / amt;
  1202.             item->window.rectEffects2.w = abs(rectTo.w - rectFrom.w) / amt;
  1203.             item->window.rectEffects2.h = abs(rectTo.h - rectFrom.h) / amt;
  1204.       Item_UpdatePosition(item);
  1205.     }
  1206.   }
  1207. }
  1208.  
  1209.  
  1210. void Script_Transition(itemDef_t *item, const char **args) {
  1211.   const char *name;
  1212.     rectDef_t rectFrom, rectTo;
  1213.   int time;
  1214.     float amt;
  1215.  
  1216.   if (String_Parse(args, &name)) {
  1217.     if ( Rect_Parse(args, &rectFrom) && Rect_Parse(args, &rectTo) && Int_Parse(args, &time) && Float_Parse(args, &amt)) {
  1218.       Menu_TransitionItemByName(item->parent, name, rectFrom, rectTo, time, amt);
  1219.     }
  1220.   }
  1221. }
  1222.  
  1223.  
  1224. void Menu_OrbitItemByName(menuDef_t *menu, const char *p, float x, float y, float cx, float cy, int time) {
  1225.   itemDef_t *item;
  1226.   int i;
  1227.   int count = Menu_ItemsMatchingGroup(menu, p);
  1228.   for (i = 0; i < count; i++) {
  1229.     item = Menu_GetMatchingItemByNumber(menu, i, p);
  1230.     if (item != NULL) {
  1231.       item->window.flags |= (WINDOW_ORBITING | WINDOW_VISIBLE);
  1232.       item->window.offsetTime = time;
  1233.       item->window.rectEffects.x = cx;
  1234.       item->window.rectEffects.y = cy;
  1235.       item->window.rectClient.x = x;
  1236.       item->window.rectClient.y = y;
  1237.       Item_UpdatePosition(item);
  1238.     }
  1239.   }
  1240. }
  1241.  
  1242.  
  1243. void Script_Orbit(itemDef_t *item, const char **args) {
  1244.   const char *name;
  1245.   float cx, cy, x, y;
  1246.   int time;
  1247.  
  1248.   if (String_Parse(args, &name)) {
  1249.     if ( Float_Parse(args, &x) && Float_Parse(args, &y) && Float_Parse(args, &cx) && Float_Parse(args, &cy) && Int_Parse(args, &time) ) {
  1250.       Menu_OrbitItemByName(item->parent, name, x, y, cx, cy, time);
  1251.     }
  1252.   }
  1253. }
  1254.  
  1255.  
  1256.  
  1257. void Script_SetFocus(itemDef_t *item, const char **args) 
  1258. {
  1259.     const char    *name;
  1260.     itemDef_t    *focusItem;
  1261.  
  1262.     if (String_Parse(args, &name)) 
  1263.     {
  1264.         focusItem = Menu_FindItemByName(item->parent, name);
  1265.         if (focusItem && !(focusItem->window.flags & WINDOW_DECORATION) && !(focusItem->window.flags & WINDOW_HASFOCUS)) 
  1266.         {
  1267.             Menu_ClearFocus(item->parent);
  1268.             focusItem->window.flags |= WINDOW_HASFOCUS;
  1269.  
  1270.             if ( focusItem->type == ITEM_TYPE_EDITFIELD ||
  1271.                  focusItem->type == ITEM_TYPE_PASSWORDFIELD )
  1272.             {
  1273.                 focusItem->cursorPos = 0;
  1274.                 g_editingField = qtrue;
  1275.                 g_editItem = focusItem;
  1276.                 DC->setOverstrikeMode(qtrue);
  1277.             }
  1278.  
  1279.             if (focusItem->onFocus) 
  1280.             {
  1281.                 Item_RunScript(focusItem, focusItem->onFocus);
  1282.             }
  1283.             
  1284.             if (DC->Assets.itemFocusSound) 
  1285.             {
  1286.                 DC->startLocalSound( DC->Assets.itemFocusSound, CHAN_LOCAL_SOUND );
  1287.             }
  1288.         }
  1289.     }
  1290. }
  1291.  
  1292. void Script_SetPlayerModel(itemDef_t *item, const char **args) {
  1293.   const char *name;
  1294.   if (String_Parse(args, &name)) {
  1295.     DC->setCVar("team_model", name);
  1296.   }
  1297. }
  1298.  
  1299. void Script_SetPlayerSkin(itemDef_t *item, const char **args) {
  1300.   const char *name;
  1301.   if (String_Parse(args, &name)) {
  1302.     DC->setCVar("team_skin", name);
  1303.   }
  1304. }
  1305.  
  1306. void Script_SetCvar(itemDef_t *item, const char **args) {
  1307.     const char *cvar, *val;
  1308.     if (String_Parse(args, &cvar) && String_Parse(args, &val)) {
  1309.         DC->setCVar(cvar, val);
  1310.     }
  1311.     
  1312. }
  1313.  
  1314. void Script_Exec(itemDef_t *item, const char **args) {
  1315.     const char *val;
  1316.     if (String_Parse(args, &val)) {
  1317.         DC->executeText(EXEC_APPEND, va("%s ; ", val));
  1318.     }
  1319. }
  1320.  
  1321. void Script_Play(itemDef_t *item, const char **args) {
  1322.     const char *val;
  1323.     if (String_Parse(args, &val)) {
  1324.         DC->startLocalSound(DC->registerSound(val), CHAN_LOCAL_SOUND);
  1325.     }
  1326. }
  1327.  
  1328. void Script_playLooped(itemDef_t *item, const char **args) {
  1329.     const char *val;
  1330.     if (String_Parse(args, &val)) {
  1331.         DC->stopBackgroundTrack();
  1332.         DC->startBackgroundTrack(val, val, qfalse);
  1333.     }
  1334. }
  1335.  
  1336.  
  1337. commandDef_t commandList[] =
  1338. {
  1339.   {"fadein", &Script_FadeIn},                   // group/name
  1340.   {"fadeout", &Script_FadeOut},                 // group/name
  1341.   {"show", &Script_Show},                       // group/name
  1342.   {"hide", &Script_Hide},                       // group/name
  1343.   {"setcolor", &Script_SetColor},               // works on this
  1344.   {"open", &Script_Open},                       // nenu
  1345.   {"close", &Script_Close},                     // menu
  1346.   {"setmenubackground", &Script_SetMenuBackground },    //menu
  1347.   {"setasset", &Script_SetAsset},               // works on this
  1348.   {"setbackground", &Script_SetBackground},     // works on this
  1349.   {"setitemcolor", &Script_SetItemColor},       // group/name
  1350.   {"setteamcolor", &Script_SetTeamColor},       // sets this background color to team color
  1351.   {"setfocus", &Script_SetFocus},               // sets this background color to team color
  1352.   {"setplayermodel", &Script_SetPlayerModel},   // sets this background color to team color
  1353.   {"setplayerskin", &Script_SetPlayerSkin},     // sets this background color to team color
  1354.   {"transition", &Script_Transition},           // group/name
  1355.   {"setcvar", &Script_SetCvar},                    // group/name
  1356.   {"exec", &Script_Exec},                        // group/name
  1357.   {"play", &Script_Play},                        // group/name
  1358.   {"playlooped", &Script_playLooped},           // group/name
  1359.   {"orbit", &Script_Orbit}                      // group/name
  1360. };
  1361.  
  1362. int scriptCommandCount = sizeof(commandList) / sizeof(commandDef_t);
  1363.  
  1364.  
  1365. void Item_RunScript(itemDef_t *item, const char *s) {
  1366.   char script[1024];
  1367.   const char *p;
  1368.   int i;
  1369.   qboolean bRan;
  1370.   memset(script, 0, sizeof(script));
  1371.   if (item && s && s[0]) {
  1372.     Q_strcat(script, 1024, s);
  1373.     p = script;
  1374.     while (1) {
  1375.       const char *command;
  1376.       // expect command then arguments, ; ends command, NULL ends script
  1377.       if (!String_Parse(&p, &command)) {
  1378.         return;
  1379.       }
  1380.  
  1381.       if (command[0] == ';' && command[1] == '\0') {
  1382.         continue;
  1383.       }
  1384.  
  1385.       bRan = qfalse;
  1386.       for (i = 0; i < scriptCommandCount; i++) {
  1387.         if (Q_stricmp(command, commandList[i].name) == 0) {
  1388.           (commandList[i].handler(item, &p));
  1389.           bRan = qtrue;
  1390.           break;
  1391.         }
  1392.       }
  1393.       // not in our auto list, pass to handler
  1394.       if (!bRan) {
  1395.         DC->runScript(&p);
  1396.       }
  1397.     }
  1398.   }
  1399. }
  1400.  
  1401.  
  1402. qboolean Item_EnableShowViaCvar(itemDef_t *item, int flag) 
  1403. {
  1404.     char        script[1024];
  1405.     const char    *p;
  1406.   
  1407.     memset(script, 0, sizeof(script));
  1408.  
  1409.     if (item && item->enableCvar && *item->enableCvar && item->cvarTest && *item->cvarTest) 
  1410.     {
  1411.         char buff[1024];
  1412.     
  1413.         DC->getCVarString(item->cvarTest, buff, sizeof(buff));
  1414.  
  1415.         Q_strcat(script, 1024, item->enableCvar);
  1416.         
  1417.         p = script;
  1418.         
  1419.         while (1) 
  1420.         {
  1421.             const char *val;
  1422.       
  1423.             // expect value then ; or NULL, NULL ends list
  1424.             if (!String_Parse(&p, &val)) 
  1425.             {
  1426.                 return (item->cvarFlags & flag) ? qfalse : qtrue;
  1427.             }
  1428.  
  1429.             if (val[0] == ';' && val[1] == '\0') 
  1430.             {
  1431.                 continue;
  1432.             }
  1433.  
  1434.             // enable it if any of the values are true
  1435.             if (item->cvarFlags & flag) 
  1436.             {
  1437.                 if (Q_stricmp(buff, val) == 0) 
  1438.                 {
  1439.                     return qtrue;
  1440.                 }
  1441.             } 
  1442.             else 
  1443.             {
  1444.                 // disable it if any of the values are true
  1445.                 if (Q_stricmp(buff, val) == 0) 
  1446.                 {
  1447.                     return qfalse;
  1448.                 }
  1449.             }
  1450.         }
  1451.  
  1452.         return (item->cvarFlags & flag) ? qfalse : qtrue;
  1453.     }
  1454.     
  1455.     return qtrue;
  1456. }
  1457.  
  1458.  
  1459. // will optionaly set focus to this item 
  1460. qboolean Item_SetFocus(itemDef_t *item, float x, float y) 
  1461. {
  1462.     int i;
  1463.     itemDef_t *oldFocus;
  1464.     sfxHandle_t *sfx = &DC->Assets.itemFocusSound;
  1465.     qboolean playSound = qfalse;
  1466.     menuDef_t *parent; // bk001206: = (menuDef_t*)item->parent;
  1467.  
  1468.     // sanity check, non-null, not a decoration and does not already have the focus
  1469.     if (item == NULL || item->window.flags & WINDOW_DECORATION || item->window.flags & WINDOW_HASFOCUS || !(item->window.flags & WINDOW_VISIBLE) || (item->window.flags & WINDOW_DISABLED)) 
  1470.     {
  1471.         return qfalse;
  1472.     }
  1473.  
  1474.     // bk001206 - this can be NULL.
  1475.     parent = (menuDef_t*)item->parent; 
  1476.       
  1477.     // items can be enabled and disabled based on cvars
  1478.     if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) {
  1479.         return qfalse;
  1480.     }
  1481.  
  1482.     if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(item, CVAR_SHOW)) {
  1483.         return qfalse;
  1484.     }
  1485.  
  1486.     oldFocus = Menu_ClearFocus(item->parent);
  1487.  
  1488.     if (item->type == ITEM_TYPE_TEXT) {
  1489.         rectDef_t r;
  1490.         r = item->textRect;
  1491.         r.y -= r.h;
  1492.         if (Rect_ContainsPoint(&r, x, y)) {
  1493.             item->window.flags |= WINDOW_HASFOCUS;
  1494.             if (item->focusSound) {
  1495.                 sfx = &item->focusSound;
  1496.             }
  1497.             playSound = qtrue;
  1498.         } else {
  1499.             if (oldFocus) {
  1500.                 oldFocus->window.flags |= WINDOW_HASFOCUS;
  1501.                 if (oldFocus->onFocus) {
  1502.                     Item_RunScript(oldFocus, oldFocus->onFocus);
  1503.                 }
  1504.             }
  1505.         }
  1506.     } else {
  1507.         item->window.flags |= WINDOW_HASFOCUS;
  1508.         if (item->onFocus) {
  1509.             Item_RunScript(item, item->onFocus);
  1510.         }
  1511.         if (item->focusSound) {
  1512.             sfx = &item->focusSound;
  1513.         }
  1514.         playSound = qtrue;
  1515.     }
  1516.  
  1517.     if (playSound && sfx) {
  1518.         DC->startLocalSound( *sfx, CHAN_AUTO );
  1519.     }
  1520.  
  1521.     for (i = 0; i < parent->itemCount; i++) {
  1522.         if (parent->items[i] == item) {
  1523.             parent->cursorItem = i;
  1524.             break;
  1525.         }
  1526.     }
  1527.  
  1528.     return qtrue;
  1529. }
  1530.  
  1531. int Item_TextScroll_MaxScroll ( itemDef_t *item ) 
  1532. {
  1533.     textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
  1534.     
  1535.     int count = scrollPtr->lineCount;
  1536.     int max   = count - (int)(item->window.rect.h / scrollPtr->lineHeight) + 1;
  1537.  
  1538.     if (max < 0) 
  1539.     {
  1540.         return 0;
  1541.     }
  1542.  
  1543.     return max;
  1544. }
  1545.  
  1546. int Item_TextScroll_ThumbPosition ( itemDef_t *item ) 
  1547. {
  1548.     float max, pos, size;
  1549.     textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
  1550.  
  1551.     max  = Item_TextScroll_MaxScroll ( item );
  1552.     size = item->window.rect.h - (SCROLLBAR_SIZE * 2) - 2;
  1553.  
  1554.     if (max > 0) 
  1555.     {
  1556.         pos = (size-SCROLLBAR_SIZE) / (float) max;
  1557.     } 
  1558.     else 
  1559.     {
  1560.         pos = 0;
  1561.     }
  1562.     
  1563.     pos *= scrollPtr->startPos;
  1564.     
  1565.     return item->window.rect.y + 1 + SCROLLBAR_SIZE + pos;
  1566. }
  1567.  
  1568. int Item_TextScroll_ThumbDrawPosition ( itemDef_t *item ) 
  1569. {
  1570.     int min, max;
  1571.  
  1572.     if (itemCapture == item) 
  1573.     {
  1574.         min = item->window.rect.y + SCROLLBAR_SIZE + 1;
  1575.         max = item->window.rect.y + item->window.rect.h - 2*SCROLLBAR_SIZE - 1;
  1576.  
  1577.         if (DC->cursory >= min + SCROLLBAR_SIZE/2 && DC->cursory <= max + SCROLLBAR_SIZE/2) 
  1578.         {
  1579.             return DC->cursory - SCROLLBAR_SIZE/2;
  1580.         }
  1581.  
  1582.         return Item_TextScroll_ThumbPosition(item);
  1583.     }
  1584.  
  1585.     return Item_TextScroll_ThumbPosition(item);
  1586. }
  1587.  
  1588. int Item_TextScroll_OverLB ( itemDef_t *item, float x, float y ) 
  1589. {
  1590.     rectDef_t        r;
  1591.     textScrollDef_t *scrollPtr;
  1592.     int                thumbstart;
  1593.     int                count;
  1594.  
  1595.     scrollPtr = (textScrollDef_t*)item->typeData;
  1596.     count     = scrollPtr->lineCount;
  1597.  
  1598.     r.x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
  1599.     r.y = item->window.rect.y;
  1600.     r.h = r.w = SCROLLBAR_SIZE;
  1601.     if (Rect_ContainsPoint(&r, x, y)) 
  1602.     {
  1603.         return WINDOW_LB_LEFTARROW;
  1604.     }
  1605.  
  1606.     r.y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
  1607.     if (Rect_ContainsPoint(&r, x, y)) 
  1608.     {
  1609.         return WINDOW_LB_RIGHTARROW;
  1610.     }
  1611.  
  1612.     thumbstart = Item_TextScroll_ThumbPosition(item);
  1613.     r.y = thumbstart;
  1614.     if (Rect_ContainsPoint(&r, x, y)) 
  1615.     {
  1616.         return WINDOW_LB_THUMB;
  1617.     }
  1618.  
  1619.     r.y = item->window.rect.y + SCROLLBAR_SIZE;
  1620.     r.h = thumbstart - r.y;
  1621.     if (Rect_ContainsPoint(&r, x, y)) 
  1622.     {
  1623.         return WINDOW_LB_PGUP;
  1624.     }
  1625.  
  1626.     r.y = thumbstart + SCROLLBAR_SIZE;
  1627.     r.h = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
  1628.     if (Rect_ContainsPoint(&r, x, y)) 
  1629.     {
  1630.         return WINDOW_LB_PGDN;
  1631.     }
  1632.  
  1633.     return 0;
  1634. }
  1635.  
  1636. void Item_TextScroll_MouseEnter (itemDef_t *item, float x, float y) 
  1637. {
  1638.     item->window.flags &= ~(WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN);
  1639.     item->window.flags |= Item_TextScroll_OverLB(item, x, y);
  1640. }
  1641.  
  1642. qboolean Item_TextScroll_HandleKey ( itemDef_t *item, int key, qboolean down, qboolean force) 
  1643. {
  1644.     textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
  1645.     int                max;
  1646.     int                viewmax;
  1647.  
  1648.     if (force || (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS)) 
  1649.     {
  1650.         max = Item_TextScroll_MaxScroll(item);
  1651.  
  1652.         viewmax = (item->window.rect.h / scrollPtr->lineHeight);
  1653.         if ( key == K_UPARROW || key == K_KP_UPARROW ) 
  1654.         {
  1655.             scrollPtr->startPos--;
  1656.             if (scrollPtr->startPos < 0)
  1657.             {
  1658.                 scrollPtr->startPos = 0;
  1659.             }
  1660.             return qtrue;
  1661.         }
  1662.  
  1663.         if ( key == K_DOWNARROW || key == K_KP_DOWNARROW ) 
  1664.         {
  1665.             scrollPtr->startPos++;
  1666.             if (scrollPtr->startPos > max)
  1667.             {
  1668.                 scrollPtr->startPos = max;
  1669.             }
  1670.  
  1671.             return qtrue;
  1672.         }
  1673.  
  1674.         // mouse hit
  1675.         if (key == K_MOUSE1 || key == K_MOUSE2) 
  1676.         {
  1677.             if (item->window.flags & WINDOW_LB_LEFTARROW) 
  1678.             {
  1679.                 scrollPtr->startPos--;
  1680.                 if (scrollPtr->startPos < 0) 
  1681.                 {
  1682.                     scrollPtr->startPos = 0;
  1683.                 }
  1684.             } 
  1685.             else if (item->window.flags & WINDOW_LB_RIGHTARROW) 
  1686.             {
  1687.                 // one down
  1688.                 scrollPtr->startPos++;
  1689.                 if (scrollPtr->startPos > max) 
  1690.                 {
  1691.                     scrollPtr->startPos = max;
  1692.                 }
  1693.             } 
  1694.             else if (item->window.flags & WINDOW_LB_PGUP) 
  1695.             {
  1696.                 // page up
  1697.                 scrollPtr->startPos -= viewmax;
  1698.                 if (scrollPtr->startPos < 0) 
  1699.                 {
  1700.                     scrollPtr->startPos = 0;
  1701.                 }
  1702.             } 
  1703.             else if (item->window.flags & WINDOW_LB_PGDN) 
  1704.             {
  1705.                 // page down
  1706.                 scrollPtr->startPos += viewmax;
  1707.                 if (scrollPtr->startPos > max) 
  1708.                 {
  1709.                     scrollPtr->startPos = max;
  1710.                 }
  1711.             } 
  1712.             else if (item->window.flags & WINDOW_LB_THUMB) 
  1713.             {
  1714.                 // Display_SetCaptureItem(item);
  1715.             } 
  1716.  
  1717.             return qtrue;
  1718.         }
  1719.  
  1720.         if ( key == K_HOME || key == K_KP_HOME) 
  1721.         {
  1722.             // home
  1723.             scrollPtr->startPos = 0;
  1724.             return qtrue;
  1725.         }
  1726.         if ( key == K_END || key == K_KP_END) 
  1727.         {
  1728.             // end
  1729.             scrollPtr->startPos = max;
  1730.             return qtrue;
  1731.         }
  1732.         if (key == K_PGUP || key == K_KP_PGUP ) 
  1733.         {
  1734.             scrollPtr->startPos -= viewmax;
  1735.             if (scrollPtr->startPos < 0) 
  1736.             {
  1737.                     scrollPtr->startPos = 0;
  1738.             }
  1739.  
  1740.             return qtrue;
  1741.         }
  1742.         if ( key == K_PGDN || key == K_KP_PGDN ) 
  1743.         {
  1744.             scrollPtr->startPos += viewmax;
  1745.             if (scrollPtr->startPos > max) 
  1746.             {
  1747.                 scrollPtr->startPos = max;
  1748.             }
  1749.             return qtrue;
  1750.         }
  1751.     }
  1752.  
  1753.     return qfalse;
  1754. }
  1755.  
  1756. int Item_ListBox_MaxScroll(itemDef_t *item) {
  1757.     listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
  1758.     int count = DC->feederCount(item->special);
  1759.     int max;
  1760.  
  1761.     if (item->window.flags & WINDOW_HORIZONTAL) 
  1762.     {
  1763.         max = count - (item->window.rect.w / listPtr->elementWidth) + 1;
  1764.     }
  1765.     else 
  1766.     {
  1767.         float h;
  1768.  
  1769.         h = item->window.rect.h;
  1770.         if ( item->type == ITEM_TYPE_COMBOBOX  )
  1771.         {
  1772.             h -= (item->window.border + listPtr->elementHeight);
  1773.         }
  1774.  
  1775.         max = count - (h / listPtr->elementHeight) + 1;
  1776.     }
  1777.  
  1778.     if (max < 0) 
  1779.     {
  1780.         return 0;
  1781.     }
  1782.  
  1783.     return max;
  1784. }
  1785.  
  1786. int Item_ListBox_ThumbPosition(itemDef_t *item) 
  1787. {
  1788.     float         max;
  1789.     float         pos;
  1790.     float         size;
  1791.     listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
  1792.  
  1793.     max = Item_ListBox_MaxScroll(item);
  1794.  
  1795.     if (item->window.flags & WINDOW_HORIZONTAL) 
  1796.     {
  1797.         size = item->window.rect.w - (SCROLLBAR_SIZE * 2) - 2;
  1798.         if (max > 0) 
  1799.         {
  1800.             pos = (size-SCROLLBAR_SIZE) / (float) max;
  1801.         } 
  1802.         else 
  1803.         {
  1804.             pos = 0;
  1805.         }
  1806.         
  1807.         pos *= listPtr->startPos;
  1808.         
  1809.         return item->window.rect.x + 1 + SCROLLBAR_SIZE + pos;
  1810.     }
  1811.     else 
  1812.     {
  1813.         float y;
  1814.  
  1815.         size = item->window.rect.h - (SCROLLBAR_SIZE * 2) - 2;
  1816.     
  1817.         if (max > 0) 
  1818.         {
  1819.             pos = (size-SCROLLBAR_SIZE) / (float) max;
  1820.         } 
  1821.         else 
  1822.         {
  1823.             pos = 0;
  1824.         }
  1825.         
  1826.         y = item->window.rect.y;
  1827.         if ( item->type == ITEM_TYPE_COMBOBOX  )
  1828.         {
  1829.             y += (item->window.border + listPtr->elementHeight);
  1830.         }
  1831.  
  1832.         pos *= listPtr->startPos;
  1833.         return y + 1 + SCROLLBAR_SIZE + pos;
  1834.     }
  1835. }
  1836.  
  1837. int Item_ListBox_ThumbDrawPosition(itemDef_t *item) 
  1838. {
  1839.     int min, max;
  1840.     listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
  1841.  
  1842.     if (itemCapture == item) 
  1843.     {
  1844.         if (item->window.flags & WINDOW_HORIZONTAL) 
  1845.         {
  1846.             min = item->window.rect.x + SCROLLBAR_SIZE + 1;
  1847.             max = item->window.rect.x + item->window.rect.w - 2*SCROLLBAR_SIZE - 1;
  1848.             if (DC->cursorx >= min + SCROLLBAR_SIZE/2 && DC->cursorx <= max + SCROLLBAR_SIZE/2) 
  1849.             {
  1850.                 return DC->cursorx - SCROLLBAR_SIZE/2;
  1851.             }
  1852.  
  1853.             return Item_ListBox_ThumbPosition(item);
  1854.         }
  1855.         else 
  1856.         {
  1857.             float y;
  1858.             float h;
  1859.  
  1860.             y = item->window.rect.y;
  1861.             h = item->window.rect.h;
  1862.             if ( item->type == ITEM_TYPE_COMBOBOX  )
  1863.             {
  1864.                 y += (item->window.border + listPtr->elementHeight);
  1865.                 h -= (item->window.border + listPtr->elementHeight);
  1866.             }
  1867.  
  1868.             min = y + SCROLLBAR_SIZE + 1;
  1869.             max = y + h - 2 * SCROLLBAR_SIZE - 1;
  1870.             if (DC->cursory >= min + SCROLLBAR_SIZE/2 && DC->cursory <= max + SCROLLBAR_SIZE/2) 
  1871.             {
  1872.                 return DC->cursory - SCROLLBAR_SIZE/2;
  1873.             }
  1874.  
  1875.             return Item_ListBox_ThumbPosition(item);
  1876.         }
  1877.     }
  1878.  
  1879.     return Item_ListBox_ThumbPosition(item);
  1880. }
  1881.  
  1882. float Item_Slider_ThumbPosition ( itemDef_t *item ) 
  1883. {
  1884.     float            value;
  1885.     float            range;
  1886.     float            x;
  1887.     editFieldDef_t    *editDef = item->typeData;
  1888.  
  1889.     if (item->text && *item->text) 
  1890.     {
  1891.         x = item->textRect.x + item->textRect.w + 8;
  1892.     } 
  1893.     else 
  1894.     {
  1895.         x = item->window.rect.x; //  + (SLIDER_THUMB_WIDTH/2);
  1896.     }
  1897.  
  1898.     if (editDef == NULL && item->cvar) 
  1899.     {
  1900.         return x;
  1901.     }
  1902.  
  1903.     value = DC->getCVarValue(item->cvar);
  1904.  
  1905.     if (value < editDef->minVal) 
  1906.     {
  1907.         value = editDef->minVal;
  1908.     } 
  1909.     else if (value > editDef->maxVal) 
  1910.     {
  1911.         value = editDef->maxVal;
  1912.     }
  1913.  
  1914.     range = editDef->maxVal - editDef->minVal;
  1915.     value -= editDef->minVal;
  1916.     value /= range;
  1917.     value *= (SLIDER_WIDTH - SLIDER_THUMB_WIDTH);
  1918.     x += value;
  1919.  
  1920.     return x;
  1921. }
  1922.  
  1923. int Item_Slider_OverSlider(itemDef_t *item, float x, float y) 
  1924. {
  1925.     rectDef_t r;
  1926.  
  1927.     r.x = Item_Slider_ThumbPosition(item);
  1928.     r.y = item->window.rect.y;
  1929.     r.w = SLIDER_THUMB_WIDTH;
  1930.     r.h = SLIDER_THUMB_HEIGHT;
  1931.  
  1932.     if (Rect_ContainsPoint(&r, x, y)) 
  1933.     {
  1934.         return WINDOW_LB_THUMB;
  1935.     }
  1936.  
  1937.     return 0;
  1938. }
  1939.  
  1940. int Item_ListBox_OverLB(itemDef_t *item, float x, float y) 
  1941. {
  1942.     rectDef_t        r;
  1943.     listBoxDef_t    *listPtr;
  1944.     int                thumbstart;
  1945.     int                count;
  1946.  
  1947.     count = DC->feederCount(item->special);
  1948.     listPtr = (listBoxDef_t*)item->typeData;
  1949.  
  1950.     if (item->window.flags & WINDOW_HORIZONTAL) {
  1951.         // check if on left arrow
  1952.         r.x = listPtr->listRect.x;
  1953.         r.y = listPtr->listRect.y + listPtr->listRect.h - SCROLLBAR_SIZE;
  1954.         r.h = r.w = SCROLLBAR_SIZE;
  1955.         if (Rect_ContainsPoint(&r, x, y)) {
  1956.             return WINDOW_LB_LEFTARROW;
  1957.         }
  1958.         // check if on right arrow
  1959.         r.x = listPtr->listRect.x + listPtr->listRect.w - SCROLLBAR_SIZE;
  1960.         if (Rect_ContainsPoint(&r, x, y)) {
  1961.             return WINDOW_LB_RIGHTARROW;
  1962.         }
  1963.         // check if on thumb
  1964.         thumbstart = Item_ListBox_ThumbPosition(item);
  1965.         r.x = thumbstart;
  1966.         if (Rect_ContainsPoint(&r, x, y)) {
  1967.             return WINDOW_LB_THUMB;
  1968.         }
  1969.         r.x = listPtr->listRect.x + SCROLLBAR_SIZE;
  1970.         r.w = thumbstart - r.x;
  1971.         if (Rect_ContainsPoint(&r, x, y)) {
  1972.             return WINDOW_LB_PGUP;
  1973.         }
  1974.         r.x = thumbstart + SCROLLBAR_SIZE;
  1975.         r.w = listPtr->listRect.x + listPtr->listRect.w - SCROLLBAR_SIZE;
  1976.         if (Rect_ContainsPoint(&r, x, y)) {
  1977.             return WINDOW_LB_PGDN;
  1978.         }
  1979.     }
  1980.     else 
  1981.     {
  1982.         if ( item->type == ITEM_TYPE_COMBOBOX )
  1983.         {
  1984.             if ( !(item->window.flags & WINDOW_DROPPED ) )
  1985.             {
  1986.                 return 0;
  1987.             }
  1988.         }
  1989.             
  1990.         r.x = listPtr->listRect.x + listPtr->listRect.w - SCROLLBAR_SIZE;
  1991.         r.y = listPtr->listRect.y;
  1992.         r.h = r.w = SCROLLBAR_SIZE;
  1993.         if (Rect_ContainsPoint(&r, x, y)) {
  1994.             return WINDOW_LB_LEFTARROW;
  1995.         }
  1996.         r.y = listPtr->listRect.y + listPtr->listRect.h - SCROLLBAR_SIZE;
  1997.         if (Rect_ContainsPoint(&r, x, y)) {
  1998.             return WINDOW_LB_RIGHTARROW;
  1999.         }
  2000.         thumbstart = Item_ListBox_ThumbPosition(item);
  2001.         r.y = thumbstart;
  2002.         if (Rect_ContainsPoint(&r, x, y)) {
  2003.             return WINDOW_LB_THUMB;
  2004.         }
  2005.         r.y = listPtr->listRect.y + SCROLLBAR_SIZE;
  2006.         r.h = thumbstart - r.y;
  2007.         if (Rect_ContainsPoint(&r, x, y)) {
  2008.             return WINDOW_LB_PGUP;
  2009.         }
  2010.         r.y = thumbstart + SCROLLBAR_SIZE;
  2011.         r.h = listPtr->listRect.y + listPtr->listRect.h - SCROLLBAR_SIZE;
  2012.         if (Rect_ContainsPoint(&r, x, y)) {
  2013.             return WINDOW_LB_PGDN;
  2014.         }
  2015.     }
  2016.     return 0;
  2017. }
  2018.  
  2019.  
  2020. void Item_ListBox_MouseEnter(itemDef_t *item, float x, float y) 
  2021. {
  2022.     rectDef_t r;
  2023.     listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
  2024.         
  2025.     item->window.flags &= ~(WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN);
  2026.     item->window.flags |= Item_ListBox_OverLB(item, x, y);
  2027.  
  2028.     if (item->window.flags & WINDOW_HORIZONTAL) 
  2029.     {
  2030.         if (!(item->window.flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN))) 
  2031.         {
  2032.             // check for selection hit as we have exausted buttons and thumb
  2033.             if (listPtr->elementStyle == LISTBOX_IMAGE) 
  2034.             {
  2035.                 r.x = listPtr->listRect.x;
  2036.                 r.y = listPtr->listRect.y;
  2037.                 r.h = listPtr->listRect.h - SCROLLBAR_SIZE;
  2038.                 r.w = listPtr->listRect.w - listPtr->drawPadding;
  2039.                 if (Rect_ContainsPoint(&r, x, y)) 
  2040.                 {
  2041.                     listPtr->cursorPos =  (int)((x - r.x) / listPtr->elementWidth)  + listPtr->startPos;
  2042.                     if (listPtr->cursorPos >= listPtr->endPos) 
  2043.                     {
  2044.                         listPtr->cursorPos = listPtr->endPos - 1;
  2045.                     }
  2046.                 }
  2047.             } 
  2048.             else 
  2049.             {
  2050.                 // text hit.. 
  2051.             }
  2052.         }
  2053.     } 
  2054.     else if (!(item->window.flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN))) 
  2055.     {
  2056.         r.x = listPtr->listRect.x;
  2057.         r.y = listPtr->listRect.y;
  2058.         r.w = listPtr->listRect.w - SCROLLBAR_SIZE;
  2059.         r.h = listPtr->listRect.h; //  - listPtr->drawPadding;
  2060.         if (Rect_ContainsPoint(&r, x, y)) 
  2061.         {            
  2062.             listPtr->cursorPos =  (int)((y - 2 - r.y) / listPtr->elementHeight)  + listPtr->startPos;
  2063.             if (listPtr->cursorPos >= listPtr->endPos) 
  2064.             {
  2065.                 listPtr->cursorPos = listPtr->endPos - 1;
  2066.             }
  2067.         }
  2068.     }
  2069. }
  2070.  
  2071. void Item_MouseEnter(itemDef_t *item, float x, float y) 
  2072. {
  2073.     rectDef_t r;
  2074.     if (!item) 
  2075.     {
  2076.         return;
  2077.     }
  2078.  
  2079.     r = item->textRect;
  2080.     r.y -= r.h;
  2081.     // in the text rect?
  2082.  
  2083.     if ( item->window.flags & WINDOW_DISABLED )
  2084.     {
  2085.         return;
  2086.     }
  2087.  
  2088.     // items can be enabled and disabled based on cvars
  2089.     if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) 
  2090.     {
  2091.         return;
  2092.     }
  2093.  
  2094.     if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(item, CVAR_SHOW)) 
  2095.     {
  2096.         return;
  2097.     }
  2098.  
  2099.     if (Rect_ContainsPoint(&r, x, y)) 
  2100.     {
  2101.         if (!(item->window.flags & WINDOW_MOUSEOVERTEXT)) 
  2102.         {
  2103.             Item_RunScript(item, item->mouseEnterText);
  2104.             item->window.flags |= WINDOW_MOUSEOVERTEXT;
  2105.         }
  2106.  
  2107.         if (!(item->window.flags & WINDOW_MOUSEOVER)) 
  2108.         {
  2109.             Item_RunScript(item, item->mouseEnter);
  2110.             Item_SetMouseOver ( item, qtrue );
  2111.         }
  2112.     } 
  2113.     else 
  2114.     {
  2115.         // not in the text rect
  2116.         if (item->window.flags & WINDOW_MOUSEOVERTEXT) 
  2117.         {
  2118.             // if we were
  2119.             Item_RunScript(item, item->mouseExitText);
  2120.             item->window.flags &= ~WINDOW_MOUSEOVERTEXT;
  2121.         }
  2122.         
  2123.         if (!(item->window.flags & WINDOW_MOUSEOVER)) 
  2124.         {
  2125.             Item_RunScript(item, item->mouseEnter);
  2126.             Item_SetMouseOver ( item, qtrue );
  2127. //            item->window.flags |= WINDOW_MOUSEOVER;
  2128.         }
  2129.  
  2130.         switch ( item->type )
  2131.         {
  2132.             case ITEM_TYPE_COMBOBOX:
  2133.             case ITEM_TYPE_LISTBOX:
  2134.                 Item_ListBox_MouseEnter(item, x, y);
  2135.                 break;
  2136.             case ITEM_TYPE_TEXTSCROLL:
  2137.                 Item_TextScroll_MouseEnter ( item, x, y );
  2138.                 break;
  2139.         }
  2140.     }
  2141. }
  2142.  
  2143. void Item_MouseLeave(itemDef_t *item) 
  2144. {
  2145.     if (!item) 
  2146.     {
  2147.         return;
  2148.     }
  2149.  
  2150.     if (item->window.flags & WINDOW_MOUSEOVERTEXT) 
  2151.     {
  2152.         Item_RunScript(item, item->mouseExitText);
  2153.         item->window.flags &= ~WINDOW_MOUSEOVERTEXT;
  2154.     }
  2155.     
  2156.     Item_RunScript(item, item->mouseExit);
  2157.     item->window.flags &= ~(WINDOW_LB_RIGHTARROW | WINDOW_LB_LEFTARROW);
  2158. }
  2159.  
  2160. itemDef_t *Menu_HitTest(menuDef_t *menu, float x, float y) {
  2161.   int i;
  2162.   for (i = 0; i < menu->itemCount; i++) {
  2163.     if (Rect_ContainsPoint(&menu->items[i]->window.rect, x, y)) {
  2164.       return menu->items[i];
  2165.     }
  2166.   }
  2167.   return NULL;
  2168. }
  2169.  
  2170. qboolean Item_OwnerDraw_HandleKey(itemDef_t *item, int key) 
  2171. {
  2172.     if (item && DC->ownerDrawHandleKey) 
  2173.     {
  2174.         if ( key == K_MOUSE1 || key == K_MOUSE2 )
  2175.         {
  2176.             if ( !Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) ) 
  2177.             {
  2178.                 return qfalse;
  2179.             }
  2180.         }
  2181.  
  2182.         return DC->ownerDrawHandleKey(item->window.ownerDraw, item->window.ownerDrawFlags, &item->special, key, item->window.ownerDrawParam );
  2183.     }
  2184.     
  2185.     return qfalse;
  2186. }
  2187.  
  2188. void Item_ListBox_FeederSelection ( itemDef_t* item, qboolean force )
  2189. {
  2190.     // Only run selection when the click on an item or hit enter
  2191.     if ( !force && item->type == ITEM_TYPE_COMBOBOX )
  2192.     {
  2193.         return;
  2194.     }
  2195.  
  2196.     DC->feederSelection(item->special, item->cursorPos);
  2197.  
  2198.     // Undrop the window
  2199.     if ( item->window.flags & WINDOW_DROPPED )
  2200.     {
  2201.         item->window.flags &= (~WINDOW_DROPPED);
  2202.         Item_UpdatePosition ( item );
  2203.  
  2204.         itemExclusive = NULL;
  2205.  
  2206.         Menu_HandleMouseMove ( (menuDef_t*)item->parent, DC->cursorx, DC->cursory );
  2207.     }
  2208. }
  2209.  
  2210. qboolean Item_ListBox_HandleKey(itemDef_t *item, int key, qboolean down, qboolean force) 
  2211. {
  2212.     listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
  2213.     int             count = DC->feederCount(item->special);
  2214.     int             max;
  2215.     int             viewmax;
  2216.  
  2217.     // Combo boxes have an extra button at the top to drop down the list
  2218.     if ( item->type == ITEM_TYPE_COMBOBOX && !itemCapture )
  2219.     {            
  2220.         // If its on the button then mark the combo box as dropped
  2221.         if ( Rect_ContainsPoint(&listPtr->comboRect, DC->cursorx, DC->cursory) )
  2222.         {
  2223.             itemExclusive = (item->window.flags&WINDOW_DROPPED)?NULL:item;
  2224.             item->window.flags ^= WINDOW_DROPPED;
  2225.             Item_UpdatePosition ( item );            
  2226.             return qtrue;
  2227.         }
  2228.  
  2229.         // If the combo box isnt droped then ignore the key
  2230.         if ( !(item->window.flags & WINDOW_DROPPED ) )
  2231.         {
  2232.             return qfalse;
  2233.         }
  2234.     }
  2235.  
  2236.     if ( force || (Rect_ContainsPoint(&listPtr->listRect, DC->cursorx, DC->cursory) && (item->window.flags & WINDOW_HASFOCUS))) 
  2237.     {
  2238.         max = Item_ListBox_MaxScroll(item);
  2239.         if (item->window.flags & WINDOW_HORIZONTAL) {
  2240.             viewmax = (listPtr->listRect.w / listPtr->elementWidth);
  2241.             if ( key == K_LEFTARROW || key == K_KP_LEFTARROW ) 
  2242.             {
  2243.                 if (!listPtr->notselectable) {
  2244.                     listPtr->cursorPos--;
  2245.                     if (listPtr->cursorPos < 0) {
  2246.                         listPtr->cursorPos = 0;
  2247.                     }
  2248.                     if (listPtr->cursorPos < listPtr->startPos) {
  2249.                         listPtr->startPos = listPtr->cursorPos;
  2250.                     }
  2251.                     if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
  2252.                         listPtr->startPos = listPtr->cursorPos - viewmax + 1;
  2253.                     }
  2254.                     item->cursorPos = listPtr->cursorPos;
  2255.                     Item_ListBox_FeederSelection ( item, qfalse );
  2256.                 }
  2257.                 else {
  2258.                     listPtr->startPos--;
  2259.                     if (listPtr->startPos < 0)
  2260.                         listPtr->startPos = 0;
  2261.                 }
  2262.                 return qtrue;
  2263.             }
  2264.             if ( key == K_RIGHTARROW || key == K_KP_RIGHTARROW ) 
  2265.             {
  2266.                 if (!listPtr->notselectable) {
  2267.                     listPtr->cursorPos++;
  2268.                     if (listPtr->cursorPos < listPtr->startPos) {
  2269.                         listPtr->startPos = listPtr->cursorPos;
  2270.                     }
  2271.                     if (listPtr->cursorPos >= count) {
  2272.                         listPtr->cursorPos = count-1;
  2273.                     }
  2274.                     if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
  2275.                         listPtr->startPos = listPtr->cursorPos - viewmax + 1;
  2276.                     }
  2277.                     item->cursorPos = listPtr->cursorPos;
  2278.                     Item_ListBox_FeederSelection ( item, qfalse );
  2279.                 }
  2280.                 else {
  2281.                     listPtr->startPos++;
  2282.                     if (listPtr->startPos >= count)
  2283.                         listPtr->startPos = count-1;
  2284.                 }
  2285.                 return qtrue;
  2286.             }
  2287.         }
  2288.         else {
  2289.             viewmax = (listPtr->listRect.h / listPtr->elementHeight);
  2290.             if ( key == K_UPARROW || key == K_KP_UPARROW ) 
  2291.             {
  2292.                 if (!listPtr->notselectable) {
  2293.                     listPtr->cursorPos--;
  2294.                     if (listPtr->cursorPos < 0) {
  2295.                         listPtr->cursorPos = 0;
  2296.                     }
  2297.                     if (listPtr->cursorPos < listPtr->startPos) {
  2298.                         listPtr->startPos = listPtr->cursorPos;
  2299.                     }
  2300.                     if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
  2301.                         listPtr->startPos = listPtr->cursorPos - viewmax + 1;
  2302.                     }
  2303.                     item->cursorPos = listPtr->cursorPos;
  2304.                     Item_ListBox_FeederSelection ( item, qfalse );
  2305.                 }
  2306.                 else {
  2307.                     listPtr->startPos--;
  2308.                     if (listPtr->startPos < 0)
  2309.                         listPtr->startPos = 0;
  2310.                 }
  2311.                 return qtrue;
  2312.             }
  2313.             if ( key == K_DOWNARROW || key == K_KP_DOWNARROW ) 
  2314.             {
  2315.                 if (!listPtr->notselectable) {
  2316.                     listPtr->cursorPos++;
  2317.                     if (listPtr->cursorPos < listPtr->startPos) {
  2318.                         listPtr->startPos = listPtr->cursorPos;
  2319.                     }
  2320.                     if (listPtr->cursorPos >= count) {
  2321.                         listPtr->cursorPos = count-1;
  2322.                     }
  2323.                     if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
  2324.                         listPtr->startPos = listPtr->cursorPos - viewmax + 1;
  2325.                     }
  2326.                     item->cursorPos = listPtr->cursorPos;
  2327.                     Item_ListBox_FeederSelection ( item, qfalse );
  2328.                 }
  2329.                 else {
  2330.                     listPtr->startPos++;
  2331.                     if (listPtr->startPos > max)
  2332.                         listPtr->startPos = max;
  2333.                 }
  2334.                 return qtrue;
  2335.             }
  2336.         }
  2337.  
  2338.         switch ( key )
  2339.         {
  2340.             case K_ENTER:
  2341.             case K_SPACE:
  2342.                 if ( item->type == ITEM_TYPE_COMBOBOX )
  2343.                 {
  2344.                     if ( !(item->window.flags & WINDOW_DROPPED ) )
  2345.                     {
  2346.                         itemExclusive = item;
  2347.                         item->window.flags |= WINDOW_DROPPED;
  2348.                         Item_UpdatePosition ( item );
  2349.                     }
  2350.                     else
  2351.                     {
  2352.                         Item_ListBox_FeederSelection ( item, qtrue );
  2353.                     }
  2354.  
  2355.                     return qtrue;
  2356.                 }
  2357.                 break;
  2358.  
  2359.             case K_MOUSE1:
  2360.             case K_MOUSE2:
  2361.             {
  2362.                 if (item->window.flags & WINDOW_LB_LEFTARROW) 
  2363.                 {
  2364.                     listPtr->startPos--;
  2365.                     if (listPtr->startPos < 0) 
  2366.                     {
  2367.                         listPtr->startPos = 0;
  2368.                     }
  2369.                 } 
  2370.                 else if (item->window.flags & WINDOW_LB_RIGHTARROW) 
  2371.                 {
  2372.                     // one down
  2373.                     listPtr->startPos++;
  2374.                     if (listPtr->startPos > max) {
  2375.                         listPtr->startPos = max;
  2376.                     }
  2377.                 } 
  2378.                 else if (item->window.flags & WINDOW_LB_PGUP) 
  2379.                 {
  2380.                     // page up
  2381.                     listPtr->startPos -= viewmax;
  2382.                     if (listPtr->startPos < 0) 
  2383.                     {
  2384.                         listPtr->startPos = 0;
  2385.                     }
  2386.                 } 
  2387.                 else if (item->window.flags & WINDOW_LB_PGDN) 
  2388.                 {
  2389.                     // page down
  2390.                     listPtr->startPos += viewmax;
  2391.                     if (listPtr->startPos > max) 
  2392.                     {
  2393.                         listPtr->startPos = max;
  2394.                     }
  2395.                 } 
  2396.                 else if (item->window.flags & WINDOW_LB_THUMB) 
  2397.                 {
  2398.                     // Display_SetCaptureItem(item);
  2399.                 } 
  2400.                 else 
  2401.                 {
  2402.                     // select an item
  2403.                     if (DC->realTime < lastListBoxClickTime && listPtr->doubleClick) 
  2404.                     {
  2405.                         Item_RunScript(item, listPtr->doubleClick);
  2406.                     }
  2407.  
  2408.                     lastListBoxClickTime = DC->realTime + DOUBLE_CLICK_DELAY;
  2409.  
  2410.                     if (item->cursorPos != listPtr->cursorPos || item->type == ITEM_TYPE_COMBOBOX ) 
  2411.                     {
  2412.                         item->cursorPos = listPtr->cursorPos;
  2413.                         Item_ListBox_FeederSelection ( item, qtrue );
  2414.                     }
  2415.                 }
  2416.                 return qtrue;
  2417.             }
  2418.  
  2419.             case K_HOME:
  2420.             case K_KP_HOME:
  2421.                 // home
  2422.                 listPtr->startPos = 0;
  2423.                 return qtrue;
  2424.         
  2425.             case K_END:
  2426.             case K_KP_END:
  2427.                 // end
  2428.                 listPtr->startPos = max;
  2429.                 return qtrue;
  2430.  
  2431.             case K_PGUP:
  2432.             case K_KP_PGUP:
  2433.                 // page up
  2434.                 if (!listPtr->notselectable) 
  2435.                 {
  2436.                     listPtr->cursorPos -= viewmax;
  2437.                     if (listPtr->cursorPos < 0) 
  2438.                     {
  2439.                         listPtr->cursorPos = 0;
  2440.                     }
  2441.                     if (listPtr->cursorPos < listPtr->startPos) 
  2442.                     {
  2443.                         listPtr->startPos = listPtr->cursorPos;
  2444.                     }
  2445.                     if (listPtr->cursorPos >= listPtr->startPos + viewmax) 
  2446.                     {
  2447.                         listPtr->startPos = listPtr->cursorPos - viewmax + 1;
  2448.                     }
  2449.                     item->cursorPos = listPtr->cursorPos;
  2450.                     Item_ListBox_FeederSelection ( item, qfalse );
  2451.                 }
  2452.                 else 
  2453.                 {
  2454.                     listPtr->startPos -= viewmax;
  2455.                     if (listPtr->startPos < 0) 
  2456.                     {
  2457.                         listPtr->startPos = 0;
  2458.                     }
  2459.                 }
  2460.             
  2461.                 return qtrue;
  2462.  
  2463.             case K_PGDN:
  2464.             case K_KP_PGDN:
  2465.                 // page down
  2466.                 if (!listPtr->notselectable) 
  2467.                 {
  2468.                     listPtr->cursorPos += viewmax;
  2469.                     if (listPtr->cursorPos < listPtr->startPos) {
  2470.                         listPtr->startPos = listPtr->cursorPos;
  2471.                     }
  2472.                     if (listPtr->cursorPos >= count) {
  2473.                         listPtr->cursorPos = count-1;
  2474.                     }
  2475.                     if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
  2476.                         listPtr->startPos = listPtr->cursorPos - viewmax + 1;
  2477.                     }
  2478.                     item->cursorPos = listPtr->cursorPos;
  2479.                     Item_ListBox_FeederSelection ( item, qfalse );
  2480.                 }
  2481.                 else {
  2482.                     listPtr->startPos += viewmax;
  2483.                     if (listPtr->startPos > max) {
  2484.                         listPtr->startPos = max;
  2485.                     }
  2486.                 }
  2487.                 return qtrue;    
  2488.         }
  2489.     }
  2490.     else if ( !itemCapture && item->type == ITEM_TYPE_COMBOBOX && (item->window.flags & WINDOW_DROPPED) )
  2491.     {
  2492.         if ( key == K_MOUSE1 || key == K_MOUSE2 )
  2493.         {
  2494.             item->window.flags &= ~WINDOW_DROPPED;
  2495.             Item_UpdatePosition ( item );
  2496.  
  2497.             itemExclusive = NULL;
  2498.  
  2499.             Menu_HandleMouseMove ( (menuDef_t*)item->parent, DC->cursorx, DC->cursory );
  2500.  
  2501.             return qtrue;
  2502.         }
  2503.     }
  2504.  
  2505.     return qfalse;
  2506. }
  2507.  
  2508. qboolean Item_YesNo_HandleKey(itemDef_t *item, int key) {
  2509.  
  2510.   if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS && item->cvar) {
  2511.         if (key == K_MOUSE1 || key == K_ENTER || key == K_MOUSE2 || key == K_MOUSE3) {
  2512.         DC->setCVar(item->cvar, va("%i", !DC->getCVarValue(item->cvar)));
  2513.           return qtrue;
  2514.         }
  2515.   }
  2516.  
  2517.   return qfalse;
  2518.  
  2519. }
  2520.  
  2521. int Item_Multi_CountSettings(itemDef_t *item) {
  2522.     multiDef_t *multiPtr = (multiDef_t*)item->typeData;
  2523.     if (multiPtr == NULL) {
  2524.         return 0;
  2525.     }
  2526.     return multiPtr->count;
  2527. }
  2528.  
  2529. int Item_Multi_FindCvarByValue(itemDef_t *item) {
  2530.     char buff[1024];
  2531.     float value = 0;
  2532.     int i;
  2533.     multiDef_t *multiPtr = (multiDef_t*)item->typeData;
  2534.     if (multiPtr) {
  2535.         if (multiPtr->strDef) {
  2536.         DC->getCVarString(item->cvar, buff, sizeof(buff));
  2537.         } else {
  2538.             value = DC->getCVarValue(item->cvar);
  2539.         }
  2540.         for (i = 0; i < multiPtr->count; i++) {
  2541.             if (multiPtr->strDef) {
  2542.                 if (Q_stricmp(buff, multiPtr->cvarStr[i]) == 0) {
  2543.                     return i;
  2544.                 }
  2545.             } else {
  2546.                  if (multiPtr->cvarValue[i] == value) {
  2547.                      return i;
  2548.                  }
  2549.              }
  2550.          }
  2551.     }
  2552.     return 0;
  2553. }
  2554.  
  2555. const char *Item_Multi_Setting(itemDef_t *item) {
  2556.     char buff[1024];
  2557.     float value = 0;
  2558.     int i;
  2559.     multiDef_t *multiPtr = (multiDef_t*)item->typeData;
  2560.     if (multiPtr) {
  2561.         if (multiPtr->strDef) {
  2562.         DC->getCVarString(item->cvar, buff, sizeof(buff));
  2563.         } else {
  2564.             value = DC->getCVarValue(item->cvar);
  2565.         }
  2566.         for (i = 0; i < multiPtr->count; i++) {
  2567.             if (multiPtr->strDef) {
  2568.                 if (Q_stricmp(buff, multiPtr->cvarStr[i]) == 0) {
  2569.                     return multiPtr->cvarList[i];
  2570.                 }
  2571.             } else {
  2572.                  if (multiPtr->cvarValue[i] == value) {
  2573.                     return multiPtr->cvarList[i];
  2574.                  }
  2575.              }
  2576.          }
  2577.     }
  2578.     return "Custom";
  2579. }
  2580.  
  2581. qboolean Item_Multi_HandleKey(itemDef_t *item, int key) {
  2582.     multiDef_t *multiPtr = (multiDef_t*)item->typeData;
  2583.     if (multiPtr) {
  2584.       if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS && item->cvar) {
  2585.             if (key == K_MOUSE1 || key == K_ENTER || key == K_MOUSE2 || key == K_MOUSE3) {
  2586.                 int current = Item_Multi_FindCvarByValue(item) + 1;
  2587.                 int max = Item_Multi_CountSettings(item);
  2588.                 if ( current < 0 || current >= max ) {
  2589.                     current = 0;
  2590.                 }
  2591.                 if (multiPtr->strDef) {
  2592.                     DC->setCVar(item->cvar, multiPtr->cvarStr[current]);
  2593.                 } else {
  2594.                     float value = multiPtr->cvarValue[current];
  2595.                     if (((float)((int) value)) == value) {
  2596.                         DC->setCVar(item->cvar, va("%i", (int) value ));
  2597.                     }
  2598.                     else {
  2599.                         DC->setCVar(item->cvar, va("%f", value ));
  2600.                     }
  2601.                 }
  2602.                 return qtrue;
  2603.             }
  2604.         }
  2605.     }
  2606.   return qfalse;
  2607. }
  2608.  
  2609. qboolean Item_TextField_HandleKey(itemDef_t *item, int key) {
  2610.     char buff[1024];
  2611.     int len;
  2612.     editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
  2613.  
  2614.     if (item->cvar) {
  2615.  
  2616.         memset(buff, 0, sizeof(buff));
  2617.         DC->getCVarString(item->cvar, buff, sizeof(buff));
  2618.         len = strlen(buff);
  2619.         if (editPtr->maxChars && len > editPtr->maxChars) {
  2620.             len = editPtr->maxChars;
  2621.         }
  2622.         if ( key & K_CHAR_FLAG ) {
  2623.             key &= ~K_CHAR_FLAG;
  2624.  
  2625.  
  2626.             if (key == 'h' - 'a' + 1 )    {    // ctrl-h is backspace
  2627.                 if ( item->cursorPos > 0 ) {
  2628.                     memmove( &buff[item->cursorPos - 1], &buff[item->cursorPos], len + 1 - item->cursorPos);
  2629.                     item->cursorPos--;
  2630.                     if (item->cursorPos < editPtr->paintOffset) {
  2631.                         editPtr->paintOffset--;
  2632.                     }
  2633.                 }
  2634.                 DC->setCVar(item->cvar, buff);
  2635.                 return qtrue;
  2636.             }
  2637.  
  2638.  
  2639.             //
  2640.             // ignore any non printable chars
  2641.             //
  2642.             if ( key < 32 || !item->cvar) {
  2643.                 return qtrue;
  2644.             }
  2645.  
  2646.             if (item->type == ITEM_TYPE_NUMERICFIELD) {
  2647.                 if (key < '0' || key > '9') {
  2648.                     return qfalse;
  2649.                 }
  2650.             }
  2651.  
  2652.             if (!DC->getOverstrikeMode()) {
  2653.                 if (( len == MAX_EDITFIELD - 1 ) || (editPtr->maxChars && len >= editPtr->maxChars)) {
  2654.                     return qtrue;
  2655.                 }
  2656.                 memmove( &buff[item->cursorPos + 1], &buff[item->cursorPos], len + 1 - item->cursorPos );
  2657.             } else {
  2658.                 if (editPtr->maxChars && item->cursorPos >= editPtr->maxChars) {
  2659.                     return qtrue;
  2660.                 }
  2661.             }
  2662.  
  2663.             buff[item->cursorPos] = key;
  2664.  
  2665.             DC->setCVar(item->cvar, buff);
  2666.  
  2667.             if (item->cursorPos < len + 1) {
  2668.                 item->cursorPos++;
  2669.                 if (editPtr->maxPaintChars && item->cursorPos > editPtr->maxPaintChars) {
  2670.                     editPtr->paintOffset++;
  2671.                 }
  2672.             }
  2673.  
  2674.         } else {
  2675.  
  2676.             if ( key == K_DEL || key == K_KP_DEL ) {
  2677.                 if ( item->cursorPos < len ) {
  2678.                     memmove( buff + item->cursorPos, buff + item->cursorPos + 1, len - item->cursorPos);
  2679.                     DC->setCVar(item->cvar, buff);
  2680.                 }
  2681.                 return qtrue;
  2682.             }
  2683.  
  2684.             if ( key == K_RIGHTARROW || key == K_KP_RIGHTARROW ) 
  2685.             {
  2686.                 if (editPtr->maxPaintChars && item->cursorPos >= editPtr->maxPaintChars && item->cursorPos < len) {
  2687.                     item->cursorPos++;
  2688.                     editPtr->paintOffset++;
  2689.                     return qtrue;
  2690.                 }
  2691.                 if (item->cursorPos < len) {
  2692.                     item->cursorPos++;
  2693.                 } 
  2694.                 return qtrue;
  2695.             }
  2696.  
  2697.             if ( key == K_LEFTARROW || key == K_KP_LEFTARROW ) 
  2698.             {
  2699.                 if ( item->cursorPos > 0 ) {
  2700.                     item->cursorPos--;
  2701.                 }
  2702.                 if (item->cursorPos < editPtr->paintOffset) {
  2703.                     editPtr->paintOffset--;
  2704.                 }
  2705.                 return qtrue;
  2706.             }
  2707.  
  2708.             if ( key == K_HOME || key == K_KP_HOME) {// || ( tolower(key) == 'a' && trap_Key_IsDown( K_CTRL ) ) ) {
  2709.                 item->cursorPos = 0;
  2710.                 editPtr->paintOffset = 0;
  2711.                 return qtrue;
  2712.             }
  2713.  
  2714.             if ( key == K_END || key == K_KP_END)  {// ( tolower(key) == 'e' && trap_Key_IsDown( K_CTRL ) ) ) {
  2715.                 item->cursorPos = len;
  2716.                 if(item->cursorPos > editPtr->maxPaintChars) {
  2717.                     editPtr->paintOffset = len - editPtr->maxPaintChars;
  2718.                 }
  2719.                 return qtrue;
  2720.             }
  2721.  
  2722.             if ( key == K_INS || key == K_KP_INS ) {
  2723.                 DC->setOverstrikeMode(!DC->getOverstrikeMode());
  2724.                 return qtrue;
  2725.             }
  2726.         }
  2727.  
  2728.         if (key == K_TAB || key == K_DOWNARROW || key == K_KP_DOWNARROW) 
  2729.         {
  2730.             g_editingField = qfalse;
  2731.             g_editItem = NULL;
  2732.         }
  2733.  
  2734.         if (key == K_UPARROW || key == K_KP_UPARROW) 
  2735.         {
  2736.             g_editingField = qfalse;
  2737.             g_editItem = NULL;
  2738.         }
  2739.  
  2740.         if ( key == K_ENTER || key == K_KP_ENTER || key == K_ESCAPE)  {
  2741.             return qfalse;
  2742.         }
  2743.  
  2744.         return qtrue;
  2745.     }
  2746.     return qfalse;
  2747.  
  2748. }
  2749.  
  2750. static void Scroll_TextScroll_AutoFunc (void *p) 
  2751. {
  2752.     scrollInfo_t *si = (scrollInfo_t*)p;
  2753.  
  2754.     if (DC->realTime > si->nextScrollTime) 
  2755.     { 
  2756.         // need to scroll which is done by simulating a click to the item
  2757.         // this is done a bit sideways as the autoscroll "knows" that the item is a listbox
  2758.         // so it calls it directly
  2759.         Item_TextScroll_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
  2760.         si->nextScrollTime = DC->realTime + si->adjustValue; 
  2761.     }
  2762.  
  2763.     if (DC->realTime > si->nextAdjustTime) 
  2764.     {
  2765.         si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
  2766.         if (si->adjustValue > SCROLL_TIME_FLOOR) 
  2767.         {
  2768.             si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
  2769.         }
  2770.     }
  2771. }
  2772.  
  2773. static void Scroll_TextScroll_ThumbFunc(void *p) 
  2774. {
  2775.     scrollInfo_t *si = (scrollInfo_t*)p;
  2776.     rectDef_t     r;
  2777.     int             pos;
  2778.     int             max;
  2779.  
  2780.     textScrollDef_t *scrollPtr = (textScrollDef_t*)si->item->typeData;
  2781.  
  2782.     if (DC->cursory != si->yStart) 
  2783.     {
  2784.         r.x = si->item->window.rect.x + si->item->window.rect.w - SCROLLBAR_SIZE - 1;
  2785.         r.y = si->item->window.rect.y + SCROLLBAR_SIZE + 1;
  2786.         r.h = si->item->window.rect.h - (SCROLLBAR_SIZE*2) - 2;
  2787.         r.w = SCROLLBAR_SIZE;
  2788.         max = Item_TextScroll_MaxScroll(si->item);
  2789.         //
  2790.         pos = (DC->cursory - r.y - SCROLLBAR_SIZE/2) * max / (r.h - SCROLLBAR_SIZE);
  2791.         if (pos < 0) 
  2792.         {
  2793.             pos = 0;
  2794.         }
  2795.         else if (pos > max) 
  2796.         {
  2797.             pos = max;
  2798.         }
  2799.  
  2800.         scrollPtr->startPos = pos;
  2801.         si->yStart = DC->cursory;
  2802.     }
  2803.  
  2804.     if (DC->realTime > si->nextScrollTime) 
  2805.     { 
  2806.         // need to scroll which is done by simulating a click to the item
  2807.         // this is done a bit sideways as the autoscroll "knows" that the item is a listbox
  2808.         // so it calls it directly
  2809.         Item_TextScroll_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
  2810.         si->nextScrollTime = DC->realTime + si->adjustValue; 
  2811.     }
  2812.  
  2813.     if (DC->realTime > si->nextAdjustTime) 
  2814.     {
  2815.         si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
  2816.         if (si->adjustValue > SCROLL_TIME_FLOOR) 
  2817.         {
  2818.             si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
  2819.         }
  2820.     }
  2821. }
  2822.  
  2823. static void Scroll_ListBox_AutoFunc(void *p) {
  2824.     scrollInfo_t *si = (scrollInfo_t*)p;
  2825.     if (DC->realTime > si->nextScrollTime) { 
  2826.         // need to scroll which is done by simulating a click to the item
  2827.         // this is done a bit sideways as the autoscroll "knows" that the item is a listbox
  2828.         // so it calls it directly
  2829.         Item_ListBox_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
  2830.         si->nextScrollTime = DC->realTime + si->adjustValue; 
  2831.     }
  2832.  
  2833.     if (DC->realTime > si->nextAdjustTime) {
  2834.         si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
  2835.         if (si->adjustValue > SCROLL_TIME_FLOOR) {
  2836.             si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
  2837.         }
  2838.     }
  2839. }
  2840.  
  2841. static void Scroll_ListBox_ThumbFunc(void *p) {
  2842.     scrollInfo_t *si = (scrollInfo_t*)p;
  2843.     rectDef_t r;
  2844.     int pos, max;
  2845.  
  2846.     listBoxDef_t *listPtr = (listBoxDef_t*)si->item->typeData;
  2847.     if (si->item->window.flags & WINDOW_HORIZONTAL) {
  2848.         if (DC->cursorx == si->xStart) {
  2849.             return;
  2850.         }
  2851.         r.x = si->item->window.rect.x + SCROLLBAR_SIZE + 1;
  2852.         r.y = si->item->window.rect.y + si->item->window.rect.h - SCROLLBAR_SIZE - 1;
  2853.         r.h = SCROLLBAR_SIZE;
  2854.         r.w = si->item->window.rect.w - (SCROLLBAR_SIZE*2) - 2;
  2855.         max = Item_ListBox_MaxScroll(si->item);
  2856.         //
  2857.         pos = (DC->cursorx - r.x - SCROLLBAR_SIZE/2) * max / (r.w - SCROLLBAR_SIZE);
  2858.         if (pos < 0) {
  2859.             pos = 0;
  2860.         }
  2861.         else if (pos > max) {
  2862.             pos = max;
  2863.         }
  2864.         listPtr->startPos = pos;
  2865.         si->xStart = DC->cursorx;
  2866.     }
  2867.     else if (DC->cursory != si->yStart) {
  2868.  
  2869.         r.x = si->item->window.rect.x + si->item->window.rect.w - SCROLLBAR_SIZE - 1;
  2870.         r.y = si->item->window.rect.y + SCROLLBAR_SIZE + 1;
  2871.         r.h = si->item->window.rect.h - (SCROLLBAR_SIZE*2) - 2;
  2872.         r.w = SCROLLBAR_SIZE;
  2873.         max = Item_ListBox_MaxScroll(si->item);
  2874.         //
  2875.         pos = (DC->cursory - r.y - SCROLLBAR_SIZE/2) * max / (r.h - SCROLLBAR_SIZE);
  2876.         if (pos < 0) {
  2877.             pos = 0;
  2878.         }
  2879.         else if (pos > max) {
  2880.             pos = max;
  2881.         }
  2882.         listPtr->startPos = pos;
  2883.         si->yStart = DC->cursory;
  2884.     }
  2885.  
  2886.     if (DC->realTime > si->nextScrollTime) { 
  2887.         // need to scroll which is done by simulating a click to the item
  2888.         // this is done a bit sideways as the autoscroll "knows" that the item is a listbox
  2889.         // so it calls it directly
  2890.         Item_ListBox_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
  2891.         si->nextScrollTime = DC->realTime + si->adjustValue; 
  2892.     }
  2893.  
  2894.     if (DC->realTime > si->nextAdjustTime) {
  2895.         si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
  2896.         if (si->adjustValue > SCROLL_TIME_FLOOR) {
  2897.             si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
  2898.         }
  2899.     }
  2900. }
  2901.  
  2902. static void Scroll_Slider_ThumbFunc ( void *p ) 
  2903. {
  2904.     float            x;
  2905.     float            value;
  2906.     float            cursorx;
  2907.     scrollInfo_t    *si = (scrollInfo_t*)p;
  2908.     editFieldDef_t    *editDef = si->item->typeData;
  2909.  
  2910.     if (si->item->text && *si->item->text) 
  2911.     {
  2912.         x = si->item->textRect.x + si->item->textRect.w + 8;
  2913.     } 
  2914.     else 
  2915.     {
  2916.         x = si->item->window.rect.x;
  2917.         x += (SLIDER_THUMB_WIDTH / 2);
  2918.     }
  2919.  
  2920.     cursorx = DC->cursorx;
  2921.  
  2922.     if (cursorx < x) 
  2923.     {
  2924.         cursorx = x;
  2925.     } 
  2926.     else if (cursorx > x + SLIDER_WIDTH - SLIDER_THUMB_WIDTH) 
  2927.     {
  2928.         cursorx = x + SLIDER_WIDTH - SLIDER_THUMB_WIDTH;
  2929.     }
  2930.     
  2931.     value = cursorx - x;
  2932.     value /= (SLIDER_WIDTH - SLIDER_THUMB_WIDTH);
  2933.     value *= (editDef->maxVal - editDef->minVal);
  2934.     value += editDef->minVal;
  2935.  
  2936.     DC->setCVar(si->item->cvar, va("%f", value));
  2937. }
  2938.  
  2939. void Item_StartCapture(itemDef_t *item, int key) {
  2940.     int flags;
  2941.     switch (item->type) {
  2942.         case ITEM_TYPE_EDITFIELD:
  2943.         case ITEM_TYPE_PASSWORDFIELD:
  2944.         case ITEM_TYPE_NUMERICFIELD:
  2945.             break;
  2946.  
  2947.         case ITEM_TYPE_COMBOBOX:
  2948.         case ITEM_TYPE_LISTBOX:
  2949.         {
  2950.             flags = Item_ListBox_OverLB(item, DC->cursorx, DC->cursory);
  2951.             if (flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW)) {
  2952.                 scrollInfo.nextScrollTime = DC->realTime + SCROLL_TIME_START;
  2953.                 scrollInfo.nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
  2954.                 scrollInfo.adjustValue = SCROLL_TIME_START;
  2955.                 scrollInfo.scrollKey = key;
  2956.                 scrollInfo.scrollDir = (flags & WINDOW_LB_LEFTARROW) ? qtrue : qfalse;
  2957.                 scrollInfo.item = item;
  2958.                 captureData = &scrollInfo;
  2959.                 captureFunc = &Scroll_ListBox_AutoFunc;
  2960.                 itemCapture = item;
  2961.             } else if (flags & WINDOW_LB_THUMB) {
  2962.                 scrollInfo.scrollKey = key;
  2963.                 scrollInfo.item = item;
  2964.                 scrollInfo.xStart = DC->cursorx;
  2965.                 scrollInfo.yStart = DC->cursory;
  2966.                 captureData = &scrollInfo;
  2967.                 captureFunc = &Scroll_ListBox_ThumbFunc;
  2968.                 itemCapture = item;
  2969.             }
  2970.             break;
  2971.         }
  2972.         case ITEM_TYPE_TEXTSCROLL:
  2973.             flags = Item_TextScroll_OverLB (item, DC->cursorx, DC->cursory);
  2974.             if (flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW)) 
  2975.             {
  2976.                 scrollInfo.nextScrollTime = DC->realTime + SCROLL_TIME_START;
  2977.                 scrollInfo.nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
  2978.                 scrollInfo.adjustValue = SCROLL_TIME_START;
  2979.                 scrollInfo.scrollKey = key;
  2980.                 scrollInfo.scrollDir = (flags & WINDOW_LB_LEFTARROW) ? qtrue : qfalse;
  2981.                 scrollInfo.item = item;
  2982.                 captureData = &scrollInfo;
  2983.                 captureFunc = &Scroll_TextScroll_AutoFunc;
  2984.                 itemCapture = item;
  2985.             } 
  2986.             else if (flags & WINDOW_LB_THUMB) 
  2987.             {
  2988.                 scrollInfo.scrollKey = key;
  2989.                 scrollInfo.item = item;
  2990.                 scrollInfo.xStart = DC->cursorx;
  2991.                 scrollInfo.yStart = DC->cursory;
  2992.                 captureData = &scrollInfo;
  2993.                 captureFunc = &Scroll_TextScroll_ThumbFunc;
  2994.                 itemCapture = item;
  2995.             }
  2996.             break;
  2997.  
  2998.         case ITEM_TYPE_SLIDER:
  2999.         {
  3000.             flags = Item_Slider_OverSlider(item, DC->cursorx, DC->cursory);
  3001.             if (flags & WINDOW_LB_THUMB) {
  3002.                 scrollInfo.scrollKey = key;
  3003.                 scrollInfo.item = item;
  3004.                 scrollInfo.xStart = DC->cursorx;
  3005.                 scrollInfo.yStart = DC->cursory;
  3006.                 captureData = &scrollInfo;
  3007.                 captureFunc = &Scroll_Slider_ThumbFunc;
  3008.                 itemCapture = item;
  3009.             }
  3010.             break;
  3011.         }
  3012.     }
  3013. }
  3014.  
  3015. void Item_StopCapture(itemDef_t *item) {
  3016.  
  3017.     Item_RunScript ( item, item->action );
  3018.  
  3019. }
  3020.  
  3021. qboolean Item_Slider_HandleKey ( itemDef_t *item, int key, qboolean down )
  3022. {
  3023.     float x, value, width, work;
  3024.  
  3025.     if (item->window.flags & WINDOW_HASFOCUS && item->cvar && Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) 
  3026.     {
  3027.         if (key == K_MOUSE1 || key == K_ENTER || key == K_MOUSE2 || key == K_MOUSE3) 
  3028.         {
  3029.             editFieldDef_t *editDef = item->typeData;
  3030.             if (editDef) 
  3031.             {
  3032.                 width = (SLIDER_WIDTH - SLIDER_THUMB_WIDTH);
  3033.                 
  3034.                 if (item->text && *item->text) 
  3035.                 {
  3036.                     x = item->textRect.x + item->textRect.w + 8;
  3037.                 } 
  3038.                 else 
  3039.                 {
  3040.                     x = item->window.rect.x + (SLIDER_THUMB_WIDTH/2);
  3041.                 }
  3042.  
  3043.                 if ( DC->cursorx <= x )
  3044.                 {
  3045.                     value = editDef->minVal;
  3046.                 }
  3047.                 else if ( DC->cursorx >= x + width )
  3048.                 {
  3049.                     value = editDef->maxVal;
  3050.                 }
  3051.                 else
  3052.                 {
  3053.                     work = DC->cursorx - x + 1;
  3054.                     value = work / width;
  3055.                     value *= (editDef->maxVal - editDef->minVal);
  3056.                     value += editDef->minVal;
  3057.                 }
  3058.                     
  3059.                 DC->setCVar(item->cvar, va("%f", value));
  3060.                 return qtrue;
  3061.             }
  3062.         }
  3063.     }
  3064.  
  3065.     return qfalse;
  3066. }
  3067.  
  3068.  
  3069. qboolean Item_HandleKey ( itemDef_t *item, int key, qboolean down )
  3070. {
  3071.     if (itemCapture) 
  3072.     {
  3073.         Item_StopCapture(itemCapture);
  3074.         itemCapture = NULL;
  3075.         captureFunc = NULL;
  3076.         captureData = NULL;
  3077.     } 
  3078.     else 
  3079.     {
  3080.       // bk001206 - parentheses
  3081.         if ( down && ( key == K_MOUSE1 || key == K_MOUSE2 || key == K_MOUSE3 ) ) 
  3082.         {
  3083.             Item_StartCapture(item, key);
  3084.         }
  3085.     }
  3086.  
  3087.     if (!down) 
  3088.     {
  3089.         return qfalse;
  3090.     }
  3091.  
  3092.     switch (item->type) 
  3093.     {
  3094.         case ITEM_TYPE_BUTTON:
  3095.             if(item->hotKey && item->hotKey == key )
  3096.             {
  3097.                 return qfalse;
  3098.             }
  3099.             return qfalse;
  3100.             break;
  3101.  
  3102.         case ITEM_TYPE_RADIOBUTTON:
  3103.             return qfalse;
  3104.  
  3105.         case ITEM_TYPE_CHECKBOX:
  3106.             return qfalse;
  3107.  
  3108.         case ITEM_TYPE_PASSWORDFIELD:
  3109.         case ITEM_TYPE_EDITFIELD:
  3110.         case ITEM_TYPE_NUMERICFIELD:
  3111.             //return Item_TextField_HandleKey(item, key);
  3112.             return qfalse;
  3113.  
  3114.         case ITEM_TYPE_COMBO:
  3115.             return qfalse;
  3116.         
  3117.         case ITEM_TYPE_COMBOBOX:
  3118.         case ITEM_TYPE_LISTBOX:
  3119.             return Item_ListBox_HandleKey(item, key, down, qfalse);
  3120.  
  3121.         case ITEM_TYPE_TEXTSCROLL:
  3122.           return Item_TextScroll_HandleKey(item, key, down, qfalse);
  3123.           break;
  3124.  
  3125.         case ITEM_TYPE_YESNO:
  3126.             return Item_YesNo_HandleKey(item, key);
  3127.  
  3128.         case ITEM_TYPE_MULTI:
  3129.             return Item_Multi_HandleKey(item, key);
  3130.  
  3131.         case ITEM_TYPE_OWNERDRAW:
  3132.             return Item_OwnerDraw_HandleKey(item, key);
  3133.  
  3134.         case ITEM_TYPE_BIND:
  3135.             return Item_Bind_HandleKey(item, key, down);
  3136.       
  3137.         case ITEM_TYPE_SLIDER:
  3138.             return Item_Slider_HandleKey(item, key, down);
  3139.     }
  3140.  
  3141.     return qfalse;
  3142. }
  3143.  
  3144. void Item_Action(itemDef_t *item) 
  3145. {
  3146.     if (item) 
  3147.     {
  3148.         Item_RunScript(item, item->action);
  3149.     }
  3150. }
  3151.  
  3152. itemDef_t *Menu_SetPrevCursorItem(menuDef_t *menu) {
  3153.   qboolean wrapped = qfalse;
  3154.     int oldCursor = menu->cursorItem;
  3155.   
  3156.   if (menu->cursorItem < 0) {
  3157.     menu->cursorItem = menu->itemCount-1;
  3158.     wrapped = qtrue;
  3159.   } 
  3160.  
  3161.   while (menu->cursorItem > -1) {
  3162.     
  3163.     menu->cursorItem--;
  3164.     if (menu->cursorItem < 0 && !wrapped) {
  3165.       wrapped = qtrue;
  3166.       menu->cursorItem = menu->itemCount -1;
  3167.     }
  3168.  
  3169.         if (Item_SetFocus(menu->items[menu->cursorItem], DC->cursorx, DC->cursory)) {
  3170.             Menu_HandleMouseMove(menu, menu->items[menu->cursorItem]->window.rect.x + 1, menu->items[menu->cursorItem]->window.rect.y + 1);
  3171.       return menu->items[menu->cursorItem];
  3172.     }
  3173.   }
  3174.     menu->cursorItem = oldCursor;
  3175.     return NULL;
  3176.  
  3177. }
  3178.  
  3179. itemDef_t *Menu_SetNextCursorItem(menuDef_t *menu) {
  3180.  
  3181.   qboolean wrapped = qfalse;
  3182.     int oldCursor = menu->cursorItem;
  3183.  
  3184.  
  3185.   if (menu->cursorItem == -1) {
  3186.     menu->cursorItem = 0;
  3187.     wrapped = qtrue;
  3188.   }
  3189.  
  3190.   while (menu->cursorItem < menu->itemCount) {
  3191.  
  3192.     menu->cursorItem++;
  3193.     if (menu->cursorItem >= menu->itemCount && !wrapped) {
  3194.       wrapped = qtrue;
  3195.       menu->cursorItem = 0;
  3196.     }
  3197.         if (Item_SetFocus(menu->items[menu->cursorItem], DC->cursorx, DC->cursory)) {
  3198.             Menu_HandleMouseMove(menu, menu->items[menu->cursorItem]->window.rect.x + 1, menu->items[menu->cursorItem]->window.rect.y + 1);
  3199.       return menu->items[menu->cursorItem];
  3200.     }
  3201.     
  3202.   }
  3203.  
  3204.     menu->cursorItem = oldCursor;
  3205.     return NULL;
  3206. }
  3207.  
  3208. static void Window_CloseCinematic(windowDef_t *window) {
  3209.     if (window->style == WINDOW_STYLE_CINEMATIC && window->cinematic >= 0) {
  3210.         DC->stopCinematic(window->cinematic);
  3211.         window->cinematic = -1;
  3212.     }
  3213. }
  3214.  
  3215. static void Menu_CloseCinematics(menuDef_t *menu) {
  3216.     if (menu) {
  3217.         int i;
  3218.         Window_CloseCinematic(&menu->window);
  3219.       for (i = 0; i < menu->itemCount; i++) {
  3220.           Window_CloseCinematic(&menu->items[i]->window);
  3221.             if (menu->items[i]->type == ITEM_TYPE_OWNERDRAW) {
  3222.                 DC->stopCinematic(0-menu->items[i]->window.ownerDraw);
  3223.             }
  3224.       }
  3225.     }
  3226. }
  3227.  
  3228. static void Display_CloseCinematics() {
  3229.     int i;
  3230.     for (i = 0; i < menuCount; i++) {
  3231.         Menu_CloseCinematics(&Menus[i]);
  3232.     }
  3233. }
  3234.  
  3235. void  Menus_Activate(menuDef_t *menu) 
  3236. {
  3237.     int i;
  3238.  
  3239.     menu->window.flags |= (WINDOW_HASFOCUS | WINDOW_VISIBLE);
  3240.  
  3241.     // Run the onOpen script if there is one
  3242.     if (menu->onOpen) 
  3243.     {
  3244.         itemDef_t item;
  3245.         item.parent = menu;
  3246.         Item_RunScript(&item, menu->onOpen);
  3247.     }
  3248.  
  3249.     if (menu->soundName && *menu->soundName) {
  3250. //        DC->stopBackgroundTrack();                    // you don't want to do this since it will reset s_rawend
  3251.         DC->startBackgroundTrack(menu->soundName, menu->soundName, qfalse);
  3252.     }
  3253.  
  3254.     menu->appearanceTime = 0;
  3255.     Display_CloseCinematics();
  3256.  
  3257.     // Close any combo boxes
  3258.     for ( i = 0; i < menu->itemCount ; i ++ )
  3259.     {
  3260.         if ( menu->items[i]->window.flags & WINDOW_DROPPED )
  3261.         {
  3262.             menu->items[i]->window.flags &= (~WINDOW_DROPPED);
  3263.             Item_UpdatePosition ( menu->items[i] );
  3264.         }
  3265.     }
  3266. }
  3267.  
  3268. int Display_VisibleMenuCount() {
  3269.     int i, count;
  3270.     count = 0;
  3271.     for (i = 0; i < menuCount; i++) {
  3272.         if (Menus[i].window.flags & (WINDOW_FORCED | WINDOW_VISIBLE)) {
  3273.             count++;
  3274.         }
  3275.     }
  3276.     return count;
  3277. }
  3278.  
  3279. void Menus_HandleOOBClick(menuDef_t *menu, int key, qboolean down) {
  3280.     if (menu) {
  3281.         int i;
  3282.         // basically the behaviour we are looking for is if there are windows in the stack.. see if 
  3283.         // the cursor is within any of them.. if not close them otherwise activate them and pass the 
  3284.         // key on.. force a mouse move to activate focus and script stuff 
  3285.         if (down && menu->window.flags & WINDOW_OOB_CLICK) {
  3286.             Menu_RunCloseScript(menu);
  3287.             menu->window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
  3288.         }
  3289.  
  3290.         for (i = 0; i < menuCount; i++) {
  3291.             if (Menu_OverActiveItem(&Menus[i], DC->cursorx, DC->cursory)) {
  3292. //                Menu_RunCloseScript(menu);
  3293. //                menu->window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
  3294. //                menu->window.flags &= ~(WINDOW_HASFOCUS);
  3295. //                Menus_Activate(&Menus[i]);
  3296.                 Menu_HandleMouseMove(&Menus[i], DC->cursorx, DC->cursory);
  3297.                 Menu_HandleKey(&Menus[i], key, down);
  3298.             }
  3299.         }
  3300.  
  3301.         if (Display_VisibleMenuCount() == 0) {
  3302.             if (DC->Pause) {
  3303.                 DC->Pause(qfalse);
  3304.             }
  3305.         }
  3306.         Display_CloseCinematics();
  3307.     }
  3308. }
  3309.  
  3310. static rectDef_t *Item_CorrectedTextRect(itemDef_t *item) {
  3311.     static rectDef_t rect;
  3312.     memset(&rect, 0, sizeof(rectDef_t));
  3313.     if (item) {
  3314.         rect = item->textRect;
  3315.         if (rect.w) {
  3316.             rect.y -= rect.h;
  3317.         }
  3318.     }
  3319.     return ▭
  3320. }
  3321.  
  3322. qboolean Menu_HandleKey(menuDef_t *menu, int key, qboolean down) 
  3323. {
  3324.     int            i;
  3325.     itemDef_t    *item = NULL;
  3326.     qboolean    inHandler = qfalse;
  3327.  
  3328.     if (inHandler) 
  3329.     {
  3330.         return qfalse;
  3331.     }
  3332.  
  3333.     inHandler = qtrue;
  3334.     if (g_waitingForKey && down) 
  3335.     {
  3336.         qboolean handled = Item_Bind_HandleKey(g_bindItem, key, down);
  3337.         inHandler = qfalse;
  3338.         return handled;
  3339.     }
  3340.  
  3341.     if (g_editingField && down) 
  3342.     {
  3343.         if (!Item_TextField_HandleKey(g_editItem, key)) 
  3344.         {
  3345.             g_editingField = qfalse;
  3346.             g_editItem = NULL;
  3347.             inHandler = qfalse;
  3348.             return qfalse;
  3349.         } 
  3350.         else if (key == K_MOUSE1 || key == K_MOUSE2 || key == K_MOUSE3) 
  3351.         {
  3352.             g_editingField = qfalse;
  3353.             g_editItem = NULL;
  3354.             Display_MouseMove(NULL, DC->cursorx, DC->cursory);
  3355.         } 
  3356.         else if (key == K_TAB || key == K_UPARROW || key == K_DOWNARROW) 
  3357.         {
  3358.             return qfalse;
  3359.         }
  3360.     }
  3361.  
  3362.     if (menu == NULL) 
  3363.     {
  3364.         inHandler = qfalse;
  3365.         return qfalse;
  3366.     }
  3367.  
  3368.         // see if the mouse is within the window bounds and if so is this a mouse click
  3369.     if (down && !(menu->window.flags & WINDOW_POPUP) && !Rect_ContainsPoint(&menu->window.rect, DC->cursorx, DC->cursory)) 
  3370.     {
  3371.         static qboolean inHandleKey = qfalse;
  3372.         // bk001206 - parentheses
  3373.         if (!inHandleKey && ( key == K_MOUSE1 || key == K_MOUSE2 || key == K_MOUSE3 ) ) 
  3374.         {
  3375.             inHandleKey = qtrue;
  3376.             Menus_HandleOOBClick(menu, key, down);
  3377.             inHandleKey = qfalse;
  3378.             inHandler = qfalse;
  3379.             return qfalse;
  3380.         }
  3381.     }
  3382.  
  3383.     // get the item with focus
  3384.     if ( itemExclusive )
  3385.     {
  3386.         item = itemExclusive;
  3387.     }
  3388.     else
  3389.     {
  3390.         for (i = 0; i < menu->itemCount; i++) 
  3391.         {
  3392.             if (menu->items[i]->window.flags & WINDOW_HASFOCUS) 
  3393.             {
  3394.                 item = menu->items[i];
  3395.             }
  3396.         }
  3397.     }
  3398.  
  3399.     if (item != NULL) 
  3400.     {
  3401.         if (Item_HandleKey(item, key, down)) 
  3402.         {
  3403.             Item_Action(item);
  3404.             inHandler = qfalse;
  3405.             return qtrue;
  3406.         }
  3407.     }
  3408.  
  3409.     if (!down) 
  3410.     {
  3411.         inHandler = qfalse;
  3412.         return qfalse;
  3413.     }
  3414.  
  3415.     // default handling
  3416.     switch ( key ) {
  3417.  
  3418.         case K_F11:
  3419.             if (DC->getCVarValue("developer")) {
  3420.                 debugMode ^= 1;
  3421.             }
  3422.             break;
  3423.  
  3424.         case K_F12:
  3425.             if (DC->getCVarValue("developer")) {
  3426.                 DC->executeText(EXEC_APPEND, "screenshot\n");
  3427.             }
  3428.             break;
  3429.         case K_LEFTARROW:
  3430.         case K_KP_LEFTARROW:
  3431.         case K_KP_UPARROW:
  3432.         case K_UPARROW:
  3433.             if ( !g_editingField )
  3434.             {
  3435.                 Menu_SetPrevCursorItem(menu);
  3436.             }
  3437.             break;
  3438.  
  3439.         case K_ESCAPE:
  3440.             if (!g_waitingForKey && menu->onESC) {
  3441.                 itemDef_t it;
  3442.             it.parent = menu;
  3443.             Item_RunScript(&it, menu->onESC);
  3444.             }
  3445.             break;
  3446.         case K_TAB:
  3447.         case K_RIGHTARROW:
  3448.         case K_KP_RIGHTARROW:
  3449.         case K_KP_DOWNARROW:
  3450.         case K_DOWNARROW:
  3451.             if ( !g_editingField )
  3452.             {
  3453.                 Menu_SetNextCursorItem(menu);
  3454.             }
  3455.             break;
  3456.  
  3457.         case K_MOUSE1:
  3458.         case K_MOUSE2:
  3459.  
  3460.             if (item) 
  3461.             {
  3462.                 if (item->type == ITEM_TYPE_TEXT) {
  3463.                     if (Rect_ContainsPoint(Item_CorrectedTextRect(item), DC->cursorx, DC->cursory)) {
  3464.                         Item_Action(item);
  3465.                     }
  3466.                 } else if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_NUMERICFIELD || item->type == ITEM_TYPE_PASSWORDFIELD) {
  3467.                     if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) {
  3468.                         item->cursorPos = 0;
  3469.                         g_editingField = qtrue;
  3470.                         g_editItem = item;
  3471.                         DC->setOverstrikeMode(qtrue);
  3472.                     }
  3473.                 } else {
  3474.                     if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) {
  3475.                         Item_Action(item);
  3476.                     }
  3477.                 }
  3478.             }
  3479.             break;
  3480.  
  3481.         case K_JOY1:
  3482.         case K_JOY2:
  3483.         case K_JOY3:
  3484.         case K_JOY4:
  3485.         case K_AUX1:
  3486.         case K_AUX2:
  3487.         case K_AUX3:
  3488.         case K_AUX4:
  3489.         case K_AUX5:
  3490.         case K_AUX6:
  3491.         case K_AUX7:
  3492.         case K_AUX8:
  3493.         case K_AUX9:
  3494.         case K_AUX10:
  3495.         case K_AUX11:
  3496.         case K_AUX12:
  3497.         case K_AUX13:
  3498.         case K_AUX14:
  3499.         case K_AUX15:
  3500.         case K_AUX16:
  3501.             break;
  3502.         case K_KP_ENTER:
  3503.         case K_ENTER:
  3504.             if (item) {
  3505.                 if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_NUMERICFIELD || item->type == ITEM_TYPE_PASSWORDFIELD ) {
  3506.                     item->cursorPos = 0;
  3507.                     g_editingField = qtrue;
  3508.                     g_editItem = item;
  3509.                     DC->setOverstrikeMode(qtrue);
  3510.                 } else {
  3511.                         Item_Action(item);
  3512.                 }
  3513.             }
  3514.             break;
  3515.  
  3516.         default:
  3517.  
  3518.             // See if a hotkey was pressed.
  3519.             for (i = 0; i < menu->itemCount; i++) 
  3520.             {
  3521.                 if ( menu->items[i]->window.flags & WINDOW_DISABLED )
  3522.                 {
  3523.                     continue;
  3524.                 }
  3525.  
  3526.                 if ((menu->items[i]->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE)) && !Item_EnableShowViaCvar(menu->items[i], CVAR_ENABLE) )
  3527.                 {
  3528.                     continue;
  3529.                 }
  3530.  
  3531.                 if ( !(menu->items[i]->window.flags & WINDOW_VISIBLE) )
  3532.                 {
  3533.                     continue;
  3534.                 }
  3535.  
  3536.                 if (menu->items[i]->hotKey == key ) 
  3537.                 {
  3538.                     Item_OwnerDraw_HandleKey ( menu->items[i], K_ENTER );
  3539.                     Item_Action(menu->items[i]);
  3540.                     inHandler = qfalse;
  3541.                     return qtrue;
  3542.                 }
  3543.             }
  3544.             break;
  3545.  
  3546.     }
  3547.     inHandler = qfalse;
  3548.  
  3549.     return qfalse;
  3550. }
  3551.  
  3552. void ToWindowCoords(float *x, float *y, windowDef_t *window) {
  3553.     if (window->border != 0) {
  3554.         *x += window->borderSize;
  3555.         *y += window->borderSize;
  3556.     } 
  3557.     *x += window->rect.x;
  3558.     *y += window->rect.y;
  3559. }
  3560.  
  3561. void Rect_ToWindowCoords(rectDef_t *rect, windowDef_t *window) {
  3562.     ToWindowCoords(&rect->x, &rect->y, window);
  3563. }
  3564.  
  3565. void Item_SetTextExtents(itemDef_t *item, int *width, int *height, const char *text) 
  3566. {
  3567.     const char *textPtr = (text) ? text : item->text;
  3568.  
  3569.     if (textPtr == NULL ) {
  3570.         return;
  3571.     }
  3572.  
  3573.     *width = item->textRect.w;
  3574.     *height = item->textRect.h;
  3575.  
  3576.     // keeps us from computing the widths and heights more than once
  3577.     if (*width == 0 || (item->type == ITEM_TYPE_OWNERDRAW && item->textalignment == ITEM_ALIGN_CENTER)) {
  3578.         int originalWidth = DC->getTextWidth(textPtr, item->textFont, item->textscale, 0);
  3579.  
  3580.         if (item->type == ITEM_TYPE_OWNERDRAW && (item->textalignment == ITEM_ALIGN_CENTER || item->textalignment == ITEM_ALIGN_RIGHT)) {
  3581.             originalWidth += DC->ownerDrawWidth(item->window.ownerDraw, item->textscale, item->textFont );
  3582.         } else if ((item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_PASSWORDFIELD) && item->textalignment == ITEM_ALIGN_CENTER && item->cvar) {
  3583.             char buff[256];
  3584.             DC->getCVarString(item->cvar, buff, 256);
  3585.             originalWidth += DC->getTextWidth(buff, item->textFont, item->textscale, 0);
  3586.         }
  3587.  
  3588.         *width = DC->getTextWidth(textPtr, item->textFont, item->textscale, 0 );
  3589.         *height = DC->getTextHeight(textPtr, item->textFont, item->textscale, 0 );
  3590.         item->textRect.w = *width;
  3591.         item->textRect.h = *height;
  3592.         item->textRect.x = item->textalignx;
  3593.         item->textRect.y = item->textaligny;
  3594.         if (item->textalignment == ITEM_ALIGN_RIGHT) {
  3595.             item->textRect.x = item->textalignx - originalWidth;
  3596.         } else if (item->textalignment == ITEM_ALIGN_CENTER) {
  3597.             item->textRect.x = item->textalignx - originalWidth / 2;
  3598.         }
  3599.  
  3600.         ToWindowCoords(&item->textRect.x, &item->textRect.y, &item->window);
  3601.     }
  3602. }
  3603.  
  3604. void Item_TextColor(itemDef_t *item, vec4_t *newColor) {
  3605.     vec4_t lowLight;
  3606.     menuDef_t *parent = (menuDef_t*)item->parent;
  3607.  
  3608.     Fade(&item->window.flags, &item->window.foreColor[3], parent->fadeClamp, &item->window.nextTime, parent->fadeCycle, qtrue, parent->fadeAmount);
  3609.  
  3610. /* no blinking for now
  3611.     if (item->window.flags & WINDOW_HASFOCUS) {
  3612.         lowLight[0] = 0.8 * parent->focusColor[0]; 
  3613.         lowLight[1] = 0.8 * parent->focusColor[1]; 
  3614.         lowLight[2] = 0.8 * parent->focusColor[2]; 
  3615.         lowLight[3] = 0.8 * parent->focusColor[3]; 
  3616.         LerpColor(parent->focusColor,lowLight,*newColor,0.5+0.5*sin(DC->realTime / PULSE_DIVISOR));
  3617.     } else 
  3618. */
  3619.     if (item->textStyle == ITEM_TEXTSTYLE_BLINK && !((DC->realTime/BLINK_DIVISOR) & 1)) {
  3620.         lowLight[0] = 0.8 * item->window.foreColor[0]; 
  3621.         lowLight[1] = 0.8 * item->window.foreColor[1]; 
  3622.         lowLight[2] = 0.8 * item->window.foreColor[2]; 
  3623.         lowLight[3] = 0.8 * item->window.foreColor[3]; 
  3624.         LerpColor(item->window.foreColor,lowLight,*newColor,0.5+0.5*sin(DC->realTime / PULSE_DIVISOR));
  3625.     } else {
  3626.         memcpy(newColor, &item->window.foreColor, sizeof(vec4_t));
  3627.         // items can be enabled and disabled based on cvars
  3628.     }
  3629.  
  3630.     if ( item->window.flags & WINDOW_DISABLED )
  3631.     {
  3632.         memcpy(newColor, &parent->disableColor, sizeof(vec4_t));
  3633.     }
  3634.     else if (item->enableCvar && *item->enableCvar && item->cvarTest && *item->cvarTest) 
  3635.     {
  3636.         if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) 
  3637.         {
  3638.             memcpy(newColor, &parent->disableColor, sizeof(vec4_t));
  3639.         }
  3640.     }
  3641. }
  3642.  
  3643. void Item_Text_AutoWrapped_Paint(itemDef_t *item) 
  3644. {
  3645.     char        text[1024];
  3646.     char        buff[1024];
  3647.     const char*    p;
  3648.     const char*    textPtr;
  3649.     const char*    newLinePtr;
  3650.     int            width;
  3651.     int            height;
  3652.     int            len;
  3653.     int            textWidth;
  3654.     int            newLine;
  3655.     int            newLineWidth;
  3656.     float        y;
  3657.     vec4_t        color;
  3658.  
  3659.     if (item->text == NULL) 
  3660.     {
  3661.         if (item->cvar == NULL) 
  3662.         {
  3663.             return;
  3664.         }
  3665.         else 
  3666.         {
  3667.             DC->getCVarString(item->cvar, text, sizeof(text));
  3668.             textPtr = text;
  3669.         }
  3670.     }
  3671.     else 
  3672.     {
  3673.         textPtr = item->text;
  3674.     }
  3675.  
  3676.     if (*textPtr == '\0') 
  3677.     {
  3678.         return;
  3679.     }
  3680.  
  3681.     Item_TextColor(item, &color);
  3682.     Item_SetTextExtents(item, &width, &height, textPtr);
  3683.  
  3684.     y = item->textaligny;
  3685.     len = 0;
  3686.     buff[0] = '\0';
  3687.     textWidth = 0;
  3688.     newLine = 0;
  3689.     newLinePtr = NULL;
  3690.     newLineWidth = 0;
  3691.     p = textPtr;
  3692.     while (p) 
  3693.     {
  3694.         if (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\0') 
  3695.         {
  3696.             newLine = len;
  3697.             newLinePtr = p+1;
  3698.             newLineWidth = textWidth;
  3699.         }
  3700.  
  3701.         textWidth = DC->getTextWidth(buff, item->textFont, item->textscale, 0);
  3702.         if ( (newLine && textWidth > item->window.rect.w - item->textalignx * 2) || *p == '\n' || *p == '\0') 
  3703.         {
  3704.             if (len) 
  3705.             {
  3706.                 if (item->textalignment == ITEM_ALIGN_LEFT) 
  3707.                 {
  3708.                     item->textRect.x = item->textalignx;
  3709.                 } 
  3710.                 else if (item->textalignment == ITEM_ALIGN_RIGHT) 
  3711.                 {
  3712.                     item->textRect.x = item->textalignx - newLineWidth;
  3713.                 } 
  3714.                 else if (item->textalignment == ITEM_ALIGN_CENTER) 
  3715.                 {
  3716.                     item->textRect.x = item->textalignx - newLineWidth / 2;
  3717.                 }
  3718.                 item->textRect.y = y;
  3719.                 ToWindowCoords(&item->textRect.x, &item->textRect.y, &item->window);
  3720.                 //
  3721.                 buff[newLine] = '\0';
  3722.                 DC->drawText(item->textRect.x, item->textRect.y, item->textFont, item->textscale, color, buff, 0, 0 );
  3723.             }
  3724.             
  3725.             if (*p == '\0') 
  3726.             {
  3727.                 break;
  3728.             }
  3729.             //
  3730.             y += height + 5;
  3731.             p = newLinePtr;
  3732.             len = 0;
  3733.             newLine = 0;
  3734.             newLineWidth = 0;
  3735.             continue;
  3736.         }
  3737.         buff[len++] = *p++;
  3738.         buff[len] = '\0';
  3739.     }
  3740. }
  3741.  
  3742. void Item_Text_Wrapped_Paint(itemDef_t *item) {
  3743.     char text[1024];
  3744.     const char *p, *start, *textPtr;
  3745.     char buff[1024];
  3746.     int width, height;
  3747.     float x, y;
  3748.     vec4_t color;
  3749.  
  3750.     // now paint the text and/or any optional images
  3751.     // default to left
  3752.  
  3753.     if (item->text == NULL) {
  3754.         if (item->cvar == NULL) {
  3755.             return;
  3756.         }
  3757.         else {
  3758.             DC->getCVarString(item->cvar, text, sizeof(text));
  3759.             textPtr = text;
  3760.         }
  3761.     }
  3762.     else {
  3763.         textPtr = item->text;
  3764.     }
  3765.     if (*textPtr == '\0') {
  3766.         return;
  3767.     }
  3768.  
  3769.     Item_TextColor(item, &color);
  3770.     Item_SetTextExtents(item, &width, &height, textPtr);
  3771.  
  3772.     x = item->textRect.x;
  3773.     y = item->textRect.y;
  3774.     start = textPtr;
  3775.     p = strchr(textPtr, '\r');
  3776.     while (p && *p) {
  3777.         strncpy(buff, start, p-start+1);
  3778.         buff[p-start] = '\0';
  3779.         DC->drawText(x, y, item->textFont, item->textscale, color, buff, 0, 0 );
  3780.         y += height + 5;
  3781.         start += p - start + 1;
  3782.         p = strchr(p+1, '\r');
  3783.     }
  3784.     DC->drawText(x, y, item->textFont, item->textscale, color, start, 0, 0 );
  3785. }
  3786.  
  3787. void Item_Text_Paint(itemDef_t *item) {
  3788.     char text[1024];
  3789.     const char *textPtr;
  3790.     int height, width;
  3791.     vec4_t color;
  3792.     int        dFlags = 0;
  3793.  
  3794.     if (item->window.flags & WINDOW_WRAPPED) {
  3795.         Item_Text_Wrapped_Paint(item);
  3796.         return;
  3797.     }
  3798.     if (item->window.flags & WINDOW_AUTOWRAPPED) {
  3799.         Item_Text_AutoWrapped_Paint(item);
  3800.         return;
  3801.     }
  3802.  
  3803.     if (item->text == NULL || !*item->text ) 
  3804.     {
  3805.         if (item->cvar == NULL) 
  3806.         {
  3807.             return;
  3808.         }
  3809.         else 
  3810.         {
  3811.             DC->getCVarString(item->cvar, text, sizeof(text));
  3812.             textPtr = text;
  3813.             
  3814.             item->textRect.w = 0;
  3815.             item->textRect.h = 0;
  3816.         }
  3817.     }
  3818.     else 
  3819.     {
  3820.         textPtr = item->text;
  3821.     }
  3822.  
  3823.     // this needs to go here as it sets extents for cvar types as well
  3824.     Item_SetTextExtents(item, &width, &height, textPtr);
  3825.  
  3826.     if (*textPtr == '\0') {
  3827.         return;
  3828.     }
  3829.  
  3830.  
  3831.     Item_TextColor(item, &color);
  3832.  
  3833.     //FIXME: this is a fucking mess
  3834. /*
  3835.     adjust = 0;
  3836.     if (item->textStyle == ITEM_TEXTSTYLE_OUTLINED || item->textStyle == ITEM_TEXTSTYLE_OUTLINESHADOWED) {
  3837.         adjust = 0.5;
  3838.     }
  3839.  
  3840.     if (item->textStyle == ITEM_TEXTSTYLE_SHADOWED || item->textStyle == ITEM_TEXTSTYLE_OUTLINESHADOWED) {
  3841.         Fade(&item->window.flags, &DC->Assets.shadowColor[3], DC->Assets.fadeClamp, &item->window.nextTime, DC->Assets.fadeCycle, qfalse);
  3842.         DC->drawText(item->textRect.x + DC->Assets.shadowX, item->textRect.y + DC->Assets.shadowY, item->textscale, DC->Assets.shadowColor, textPtr, adjust);
  3843.     }
  3844. */
  3845.  
  3846.     if (item->textStyle == ITEM_TEXTSTYLE_OUTLINED )
  3847.     {
  3848.         dFlags |= DT_OUTLINE;
  3849.     }
  3850.  
  3851. //    if (item->textStyle == ITEM_TEXTSTYLE_OUTLINED || item->textStyle == ITEM_TEXTSTYLE_OUTLINESHADOWED) {
  3852. //        Fade(&item->window.flags, &item->window.outlineColor[3], DC->Assets.fadeClamp, &item->window.nextTime, DC->Assets.fadeCycle, qfalse);
  3853. //        /*
  3854. //        Text_Paint(item->textRect.x-1, item->textRect.y-1, item->textscale, item->window.foreColor, textPtr, adjust);
  3855. //        Text_Paint(item->textRect.x, item->textRect.y-1, item->textscale, item->window.foreColor, textPtr, adjust);
  3856. //        Text_Paint(item->textRect.x+1, item->textRect.y-1, item->textscale, item->window.foreColor, textPtr, adjust);
  3857. //        Text_Paint(item->textRect.x-1, item->textRect.y, item->textscale, item->window.foreColor, textPtr, adjust);
  3858. //        Text_Paint(item->textRect.x+1, item->textRect.y, item->textscale, item->window.foreColor, textPtr, adjust);
  3859. //        Text_Paint(item->textRect.x-1, item->textRect.y+1, item->textscale, item->window.foreColor, textPtr, adjust);
  3860. //        Text_Paint(item->textRect.x, item->textRect.y+1, item->textscale, item->window.foreColor, textPtr, adjust);
  3861. //        Text_Paint(item->textRect.x+1, item->textRect.y+1, item->textscale, item->window.foreColor, textPtr, adjust);
  3862. //        */
  3863. //        DC->drawText(item->textRect.x - 1, item->textRect.y + 1, item->textscale * 1.02, item->window.outlineColor, textPtr, adjust);
  3864. //    }
  3865.  
  3866.     DC->drawText(item->textRect.x, item->textRect.y, item->textFont, item->textscale, color, textPtr, 0, dFlags );
  3867.  
  3868.  
  3869.     if (item->text2)    // Is there a second line of text?
  3870.     {
  3871.         Item_TextColor(item, &color);
  3872.         DC->drawText(item->textRect.x + item->text2alignx, item->textRect.y + item->text2aligny, item->textFont, item->textscale, color, item->text2, 0, dFlags );
  3873.     }
  3874.  
  3875. }
  3876.  
  3877.  
  3878.  
  3879. //float            trap_Cvar_VariableValue( const char *var_name );
  3880. //void            trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
  3881.  
  3882. void Item_TextField_Paint(itemDef_t *item) 
  3883. {
  3884.     char            buff[1024];
  3885.     vec4_t            newColor;
  3886.     int                offset;
  3887.     menuDef_t        *parent = (menuDef_t*)item->parent;
  3888.     editFieldDef_t    *editPtr = (editFieldDef_t*)item->typeData;
  3889.  
  3890.     buff[0] = '\0';
  3891.  
  3892.     if (item->cvar) 
  3893.     {
  3894.         DC->getCVarString(item->cvar, buff, sizeof(buff));
  3895.     } 
  3896.  
  3897.     if ( item->text && *item->text )
  3898.     {
  3899.         Item_Text_Paint(item);
  3900.     }
  3901.     else
  3902.     {
  3903.         item->textRect.w = 0;
  3904.         item->textRect.h = 0;
  3905.         item->textRect.x = item->window.rect.x + item->textalignx;
  3906.         item->textRect.y = item->window.rect.y + item->textaligny;
  3907.     }
  3908.  
  3909.     // If this is a password field then we need to render *'s instead of the real chars
  3910.     if ( item->type == ITEM_TYPE_PASSWORDFIELD )
  3911.     {
  3912.         // Fill the string with stars
  3913.         for ( offset = 0; buff[offset]; offset++ )
  3914.             buff[offset] = '*';
  3915.     }
  3916.  
  3917.     parent = (menuDef_t*)item->parent;
  3918.  
  3919. /* No more focus blinking
  3920.     if (item->window.flags & WINDOW_HASFOCUS) {
  3921.         lowLight[0] = 0.8 * parent->focusColor[0]; 
  3922.         lowLight[1] = 0.8 * parent->focusColor[1]; 
  3923.         lowLight[2] = 0.8 * parent->focusColor[2]; 
  3924.         lowLight[3] = 0.8 * parent->focusColor[3]; 
  3925.         LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin(DC->realTime / PULSE_DIVISOR));
  3926.     } else {
  3927.         memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
  3928.     }
  3929. */
  3930.     memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
  3931.  
  3932.     offset = (item->text && *item->text) ? 8 : 0;
  3933.  
  3934.     if ((item->window.flags & WINDOW_HASFOCUS) && g_editingField) 
  3935.     {
  3936.         char cursor = DC->getOverstrikeMode() ? '_' : '|';
  3937.         DC->drawTextWithCursor(item->textRect.x + item->textRect.w + offset, item->textRect.y, item->textFont, item->textscale, newColor, buff + editPtr->paintOffset, editPtr->maxPaintChars, 0, item->cursorPos - editPtr->paintOffset, cursor );
  3938.     } 
  3939.     else 
  3940.     {
  3941.         DC->drawText(item->textRect.x + item->textRect.w + offset, item->textRect.y, item->textFont, item->textscale, newColor, buff + editPtr->paintOffset, editPtr->maxPaintChars, 0 );
  3942.     }
  3943. }
  3944.  
  3945. void Item_YesNo_Paint(itemDef_t *item) 
  3946. {
  3947.     vec4_t    newColor;
  3948.     float    value;
  3949.  
  3950.     value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
  3951.  
  3952.     memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
  3953.  
  3954.     if (item->text) 
  3955.     {
  3956.         Item_Text_Paint(item);
  3957.         DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textFont, item->textscale, newColor, (value != 0) ? "Yes" : "No", 0, 0);
  3958.     } 
  3959.     else 
  3960.     {
  3961.         DC->drawText(item->textRect.x, item->textRect.y, item->textFont, item->textscale, newColor, (value != 0) ? "Yes" : "No", 0, 0);
  3962.     }
  3963. }
  3964.  
  3965. void Item_Multi_Paint(itemDef_t *item) 
  3966. {
  3967.     vec4_t newColor;
  3968.     const char *text = "";
  3969.  
  3970.      memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
  3971.  
  3972.     text = Item_Multi_Setting(item);
  3973.  
  3974.     if (item->text) 
  3975.     {
  3976.         Item_Text_Paint(item);
  3977.         DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textFont, item->textscale, newColor, text, 0, 0);
  3978.     } 
  3979.     else 
  3980.     {
  3981.         DC->drawText(item->textRect.x, item->textRect.y, item->textFont, item->textscale, newColor, text, 0, 0 );
  3982.     }
  3983. }
  3984.  
  3985.  
  3986. typedef struct {
  3987.     char    *command;
  3988.     int        id;
  3989.     int        defaultbind1;
  3990.     int        defaultbind2;
  3991.     int        bind1;
  3992.     int        bind2;
  3993. } bind_t;
  3994.  
  3995. typedef struct
  3996. {
  3997.     char*    name;
  3998.     float    defaultvalue;
  3999.     float    value;    
  4000. } configcvar_t;
  4001.  
  4002.  
  4003. static bind_t g_bindings[] = 
  4004. {
  4005.     {"+scores",             K_TAB,                -1,        -1, -1},
  4006.     {"+speed",              K_SHIFT,            -1,        -1,    -1},
  4007.     {"+forward",          K_UPARROW,            -1,        -1, -1},
  4008.     {"+back",              K_DOWNARROW,        -1,        -1, -1},
  4009.     {"+moveleft",         ',',                -1,        -1, -1},
  4010.     {"+moveright",          '.',                -1,        -1, -1},
  4011.     {"+moveup",             K_SPACE,            -1,        -1, -1},
  4012.     {"+movedown",         'c',                -1,        -1, -1},
  4013.     {"+left",              K_LEFTARROW,        -1,        -1, -1},
  4014.     {"+right",              K_RIGHTARROW,        -1,        -1, -1},
  4015.     {"+strafe",          K_ALT,                -1,        -1, -1},
  4016.     {"+lookup",          K_PGDN,            -1,        -1, -1},
  4017.     {"+lookdown",          K_DEL,                -1,        -1, -1},
  4018.     {"+mlook",              '/',                -1,        -1, -1},
  4019.     {"centerview",         K_END,                -1,        -1, -1},
  4020.     {"weapon 1",         '1',                -1,        -1, -1},
  4021.     {"weapon 2",         '2',                -1,        -1, -1},
  4022.     {"weapon 3",         '3',                -1,        -1, -1},
  4023.     {"weapon 4",         '4',                -1,        -1, -1},
  4024.     {"weapon 5",         '5',                -1,        -1, -1},
  4025.     {"weapon 6",         '6',                -1,        -1, -1},
  4026.     {"weapon 7",         '7',                -1,        -1, -1},
  4027.     {"weapon 8",         '8',                -1,        -1, -1},
  4028.     {"weapon 9",         '9',                -1,        -1, -1},
  4029.     {"weapon 10",         '0',                -1,        -1, -1},
  4030.     {"weapon 11",         -1,                -1,        -1, -1},
  4031.     {"weapon 12",         -1,                -1,        -1, -1},
  4032.     {"weapon 13",         -1,                -1,        -1, -1},
  4033.     {"+attack",          K_CTRL,            -1,        -1, -1},
  4034.     {"+altattack",         K_MOUSE2,            -1,        -1,    -1},
  4035.     {"weapprev",         '[',                -1,        -1, -1},
  4036.     {"weapnext",          ']',                -1,        -1, -1},
  4037.     {"weaplast",          -1,                -1,        -1, -1},
  4038.     {"messagemode",        't',                -1,        -1, -1},
  4039.     {"messagemode2",    'y',                -1,        -1, -1},
  4040.     {"messagemode3",    -1,                    -1,        -1, -1},
  4041.     {"messagemode4",    -1,                    -1,        -1, -1},
  4042.     {"+reload",            K_MOUSE3,            -1,        -1,    -1},
  4043.     {"+zoomin",            '=',                -1,        -1,    -1},
  4044.     {"+zoomout",        '-',                -1,        -1,    -1},
  4045.     {"+firemode",        'r',                -1,        -1,    -1},
  4046.     {"ui_objectives",    'o',                -1,        -1, -1},
  4047.     {"ui_radio",        'u',                -1,        -1,    -1},
  4048.     {"ui_outfitting",    'b',                -1,        -1, -1},
  4049.     {"ui_team",            'n',                -1,        -1, -1},
  4050.     {"+automap",        'm',                -1,        -1,    -1},
  4051.     {"+lean",            -1,                    -1,        -1,    -1},
  4052.     {"+leanleft",        'q',                -1,        -1,    -1},
  4053.     {"+leanright",        'e',                -1,        -1,    -1},
  4054.     {"+autorun",        K_KP_NUMLOCK,        -1,        -1,    -1},
  4055.     {"drop",            'f',                -1,        -1, -1},
  4056.     {"+goggles",        K_ENTER,            -1,        -1,    -1},
  4057.     {"vote yes",        K_F1,                -1,        -1,    -1},
  4058.     {"vote no",            K_F2,                -1,        -1,    -1},
  4059.     {"+use",            'x',                -1,        -1,    -1},
  4060.     {"dropitem",        -1,                    -1,        -1,    -1},
  4061. };
  4062.  
  4063.  
  4064. static const int g_bindCount = sizeof(g_bindings) / sizeof(bind_t);
  4065.  
  4066. /*
  4067. =================
  4068. Controls_GetKeyAssignment
  4069. =================
  4070. */
  4071. static void Controls_GetKeyAssignment (char *command, int *twokeys)
  4072. {
  4073.     int        count;
  4074.     int        j;
  4075.     char    b[256];
  4076.  
  4077.     twokeys[0] = twokeys[1] = -1;
  4078.     count = 0;
  4079.  
  4080.     for ( j = 0; j < 256; j++ )
  4081.     {
  4082.         DC->getBindingBuf( j, b, 256 );
  4083.         if ( *b == 0 ) {
  4084.             continue;
  4085.         }
  4086.         if ( !Q_stricmp( b, command ) ) {
  4087.             twokeys[count] = j;
  4088.             count++;
  4089.             if (count == 2) {
  4090.                 break;
  4091.             }
  4092.         }
  4093.     }
  4094. }
  4095.  
  4096. /*
  4097. =================
  4098. Controls_GetConfig
  4099. =================
  4100. */
  4101. void Controls_GetConfig( void )
  4102. {
  4103.     int        i;
  4104.     int        twokeys[2];
  4105.  
  4106.     // iterate each command, get its numeric binding
  4107.     for (i=0; i < g_bindCount; i++)
  4108.     {
  4109.  
  4110.         Controls_GetKeyAssignment(g_bindings[i].command, twokeys);
  4111.  
  4112.         g_bindings[i].bind1 = twokeys[0];
  4113.         g_bindings[i].bind2 = twokeys[1];
  4114.     }
  4115. }
  4116.  
  4117. /*
  4118. =================
  4119. Controls_SetConfig
  4120. =================
  4121. */
  4122. void Controls_SetConfig(qboolean restart)
  4123. {
  4124.     int        i;
  4125.  
  4126.     // iterate each command, get its numeric binding
  4127.     for (i=0; i < g_bindCount; i++)
  4128.     {
  4129.  
  4130.         if (g_bindings[i].bind1 != -1)
  4131.         {    
  4132.             DC->setBinding( g_bindings[i].bind1, g_bindings[i].command );
  4133.  
  4134.             if (g_bindings[i].bind2 != -1)
  4135.                 DC->setBinding( g_bindings[i].bind2, g_bindings[i].command );
  4136.         }
  4137.     }
  4138.  
  4139.     //if ( s_controls.invertmouse.curvalue )
  4140.     //    DC->setCVar("m_pitch", va("%f),-fabs( DC->getCVarValue( "m_pitch" ) ) );
  4141.     //else
  4142.     //    trap_Cvar_SetValue( "m_pitch", fabs( trap_Cvar_VariableValue( "m_pitch" ) ) );
  4143.  
  4144.     //trap_Cvar_SetValue( "m_filter", s_controls.smoothmouse.curvalue );
  4145.     //trap_Cvar_SetValue( "cl_run", s_controls.alwaysrun.curvalue );
  4146.     //trap_Cvar_SetValue( "cg_autoswitch", s_controls.autoswitch.curvalue );
  4147.     //trap_Cvar_SetValue( "sensitivity", s_controls.sensitivity.curvalue );
  4148.     //trap_Cvar_SetValue( "in_joystick", s_controls.joyenable.curvalue );
  4149.     //trap_Cvar_SetValue( "joy_threshold", s_controls.joythreshold.curvalue );
  4150.     //trap_Cvar_SetValue( "cl_freelook", s_controls.freelook.curvalue );
  4151.     if (restart)
  4152.     {
  4153.         DC->executeText(EXEC_APPEND, "in_restart\n");
  4154.     }
  4155.  
  4156. }
  4157.  
  4158. /*
  4159. =================
  4160. Controls_SetDefaults
  4161. =================
  4162. */
  4163. void Controls_SetDefaults( void )
  4164. {
  4165.     int    i;
  4166.  
  4167.     // iterate each command, set its default binding
  4168.   for (i=0; i < g_bindCount; i++)
  4169.     {
  4170.         g_bindings[i].bind1 = g_bindings[i].defaultbind1;
  4171.         g_bindings[i].bind2 = g_bindings[i].defaultbind2;
  4172.     }
  4173.  
  4174.     //s_controls.invertmouse.curvalue  = Controls_GetCvarDefault( "m_pitch" ) < 0;
  4175.     //s_controls.smoothmouse.curvalue  = Controls_GetCvarDefault( "m_filter" );
  4176.     //s_controls.alwaysrun.curvalue    = Controls_GetCvarDefault( "cl_run" );
  4177.     //s_controls.autoswitch.curvalue   = Controls_GetCvarDefault( "cg_autoswitch" );
  4178.     //s_controls.sensitivity.curvalue  = Controls_GetCvarDefault( "sensitivity" );
  4179.     //s_controls.joyenable.curvalue    = Controls_GetCvarDefault( "in_joystick" );
  4180.     //s_controls.joythreshold.curvalue = Controls_GetCvarDefault( "joy_threshold" );
  4181.     //s_controls.freelook.curvalue     = Controls_GetCvarDefault( "cl_freelook" );
  4182. }
  4183.  
  4184. int BindingIDFromName(const char *name) {
  4185.     int i;
  4186.   for (i=0; i < g_bindCount; i++)
  4187.     {
  4188.         if (Q_stricmp(name, g_bindings[i].command) == 0) {
  4189.             return i;
  4190.         }
  4191.     }
  4192.     return -1;
  4193. }
  4194.  
  4195. char g_nameBind1[32];
  4196. char g_nameBind2[32];
  4197.  
  4198. void BindingFromName(const char *cvar) {
  4199.     int    i, b1, b2;
  4200.  
  4201.     // iterate each command, set its default binding
  4202.     for (i=0; i < g_bindCount; i++)
  4203.     {
  4204.         if (Q_stricmp(cvar, g_bindings[i].command) == 0) {
  4205.             b1 = g_bindings[i].bind1;
  4206.             if (b1 == -1) {
  4207.                 break;
  4208.             }
  4209.                 DC->keynumToStringBuf( b1, g_nameBind1, 32 );
  4210.                 Q_strupr(g_nameBind1);
  4211.  
  4212.                 b2 = g_bindings[i].bind2;
  4213.                 if (b2 != -1)
  4214.                 {
  4215.                     DC->keynumToStringBuf( b2, g_nameBind2, 32 );
  4216.                     Q_strupr(g_nameBind2);
  4217.                     strcat( g_nameBind1, " or " );
  4218.                     strcat( g_nameBind1, g_nameBind2 );
  4219.                 }
  4220.             return;
  4221.         }
  4222.     }
  4223.     strcpy(g_nameBind1, "???");
  4224. }
  4225.  
  4226. void Item_Slider_Paint(itemDef_t *item) 
  4227. {
  4228.     vec4_t newColor;
  4229.     float x, y, value;
  4230.  
  4231.     value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
  4232.  
  4233.     memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
  4234.  
  4235.     y = item->window.rect.y;
  4236.     if (item->text && *item->text ) 
  4237.     {
  4238.         Item_Text_Paint(item);
  4239.         x = item->textRect.x + item->textRect.w + 8;
  4240.     } 
  4241.     else 
  4242.     {
  4243.         x = item->window.rect.x;
  4244.     }
  4245.  
  4246.     DC->setColor(newColor);
  4247.     DC->drawHandlePic( x, y, SLIDER_WIDTH, SLIDER_HEIGHT, DC->Assets.sliderBar );
  4248.  
  4249.     x = Item_Slider_ThumbPosition(item);
  4250.     DC->drawHandlePic( x, y, SLIDER_THUMB_WIDTH, SLIDER_THUMB_HEIGHT, DC->Assets.sliderThumb );
  4251.  
  4252.     DC->setColor ( NULL );
  4253. }
  4254.  
  4255. void Item_Bind_Paint(itemDef_t *item) {
  4256.     vec4_t newColor, lowLight;
  4257.     float value;
  4258.     int maxChars = 0;
  4259.     menuDef_t *parent = (menuDef_t*)item->parent;
  4260.     editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
  4261.     if (editPtr) {
  4262.         maxChars = editPtr->maxPaintChars;
  4263.     }
  4264.  
  4265.     value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
  4266.  
  4267.     if (item->window.flags & WINDOW_HASFOCUS) {
  4268.         if (g_bindItem == item && Display_KeyBindPending ( ) ) {
  4269.             lowLight[0] = 0.8f * 1.0f;
  4270.             lowLight[1] = 0.8f * 0.0f;
  4271.             lowLight[2] = 0.8f * 0.0f;
  4272.             lowLight[3] = 0.8f * 1.0f;
  4273.  
  4274.             LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin(DC->realTime / PULSE_DIVISOR));
  4275.         } else {
  4276.  
  4277.             /* no more blinking
  4278.             lowLight[0] = 0.8f * parent->focusColor[0]; 
  4279.             lowLight[1] = 0.8f * parent->focusColor[1]; 
  4280.             lowLight[2] = 0.8f * parent->focusColor[2]; 
  4281.             lowLight[3] = 0.8f * parent->focusColor[3]; 
  4282.             */
  4283.  
  4284.             memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
  4285.         }
  4286.     } else {
  4287.         memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
  4288.     }
  4289.  
  4290.     if (item->text) {
  4291.         Item_Text_Paint(item);
  4292.         BindingFromName(item->cvar);
  4293.         DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textFont, item->textscale, newColor, g_nameBind1, maxChars, 0 );
  4294.     } else {
  4295.         DC->drawText(item->textRect.x, item->textRect.y, item->textFont, item->textscale, newColor, (value != 0) ? "FIXME" : "FIXME", maxChars, 0 );
  4296.     }
  4297. }
  4298.  
  4299. qboolean Display_KeyBindPending() {
  4300.     return g_waitingForKey;
  4301. }
  4302.  
  4303. qboolean Item_Bind_HandleKey(itemDef_t *item, int key, qboolean down) {
  4304.     int            id;
  4305.     int            i;
  4306.  
  4307.     if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && !g_waitingForKey)
  4308.     {
  4309.         if (down)
  4310.         {
  4311.             if (key == K_MOUSE1 || key == K_ENTER) 
  4312.             {
  4313.                 g_waitingForKey = qtrue;
  4314.                 g_bindItem = item;
  4315.                 return qtrue;
  4316.             }
  4317.             else if (key == K_BACKSPACE || key == K_DEL)
  4318.             {
  4319.                 id = BindingIDFromName(item->cvar);
  4320.                 if (id != -1) 
  4321.                 {
  4322.                     if ( g_bindings[id].bind1 != -1 )
  4323.                     {
  4324.                         DC->setBinding ( g_bindings[id].bind1, "" );
  4325.                     }
  4326.                     
  4327.                     if ( g_bindings[id].bind2 != -1 )
  4328.                     {
  4329.                         DC->setBinding ( g_bindings[id].bind2, "" );
  4330.                     }
  4331.  
  4332.                     g_bindings[id].bind1 = -1;
  4333.                     g_bindings[id].bind2 = -1;
  4334.                 }
  4335.                 Controls_SetConfig(qfalse);
  4336.                 g_waitingForKey = qfalse;
  4337.                 g_bindItem = NULL;
  4338.                 return qtrue;
  4339.             }
  4340.         }
  4341.         return qfalse;
  4342.     }
  4343.     else
  4344.     {
  4345.         if (!g_waitingForKey || g_bindItem == NULL) {
  4346. //            return qtrue;
  4347.             return qfalse;
  4348.         }
  4349.  
  4350.         if (key & K_CHAR_FLAG) {
  4351.             return qtrue;
  4352.         }
  4353.  
  4354.         switch (key)
  4355.         {
  4356.             case K_ESCAPE:
  4357.                 g_waitingForKey = qfalse;
  4358.                 return qtrue;
  4359.     
  4360.             case '`':
  4361.                 return qtrue;
  4362.         }
  4363.     }
  4364.  
  4365.     if (key != -1)
  4366.     {
  4367.  
  4368.         for (i=0; i < g_bindCount; i++)
  4369.         {
  4370.  
  4371.             if (g_bindings[i].bind2 == key) {
  4372.                 g_bindings[i].bind2 = -1;
  4373.             }
  4374.  
  4375.             if (g_bindings[i].bind1 == key)
  4376.             {
  4377.                 g_bindings[i].bind1 = g_bindings[i].bind2;
  4378.                 g_bindings[i].bind2 = -1;
  4379.             }
  4380.         }
  4381.     }
  4382.  
  4383.  
  4384.     id = BindingIDFromName(item->cvar);
  4385.  
  4386.     if (id != -1) {
  4387.         if (key == -1) {
  4388.             if( g_bindings[id].bind1 != -1 ) {
  4389.                 DC->setBinding( g_bindings[id].bind1, "" );
  4390.                 g_bindings[id].bind1 = -1;
  4391.             }
  4392.             if( g_bindings[id].bind2 != -1 ) {
  4393.                 DC->setBinding( g_bindings[id].bind2, "" );
  4394.                 g_bindings[id].bind2 = -1;
  4395.             }
  4396.         }
  4397.         else if (g_bindings[id].bind1 == -1) {
  4398.             g_bindings[id].bind1 = key;
  4399.         }
  4400.         else if (g_bindings[id].bind1 != key && g_bindings[id].bind2 == -1) {
  4401.             g_bindings[id].bind2 = key;
  4402.         }
  4403.         else {
  4404.             DC->setBinding( g_bindings[id].bind1, "" );
  4405.             DC->setBinding( g_bindings[id].bind2, "" );
  4406.             g_bindings[id].bind1 = key;
  4407.             g_bindings[id].bind2 = -1;
  4408.         }                        
  4409.     }
  4410.  
  4411.     Controls_SetConfig(qfalse);    
  4412.     g_waitingForKey = qfalse;
  4413.  
  4414.     return qtrue;
  4415. }
  4416.  
  4417.  
  4418.  
  4419. void AdjustFrom640(float *x, float *y, float *w, float *h) {
  4420.     //*x = *x * DC->scale + DC->bias;
  4421.     *x *= DC->xscale;
  4422.     *y *= DC->yscale;
  4423.     *w *= DC->xscale;
  4424.     *h *= DC->yscale;
  4425. }
  4426.  
  4427. void Item_Model_Paint(itemDef_t *item) {
  4428.     float x, y, w, h;
  4429.     refdef_t refdef;
  4430.     refEntity_t        ent;
  4431.     vec3_t            mins, maxs, origin;
  4432.     vec3_t            angles;
  4433.     modelDef_t *modelPtr = (modelDef_t*)item->typeData;
  4434.  
  4435.     if (modelPtr == NULL) {
  4436.         return;
  4437.     }
  4438.  
  4439.     // setup the refdef
  4440.     memset( &refdef, 0, sizeof( refdef ) );
  4441.     refdef.rdflags = RDF_NOWORLDMODEL;
  4442.     AxisClear( refdef.viewaxis );
  4443.     x = item->window.rect.x+1;
  4444.     y = item->window.rect.y+1;
  4445.     w = item->window.rect.w-2;
  4446.     h = item->window.rect.h-2;
  4447.  
  4448.     AdjustFrom640( &x, &y, &w, &h );
  4449.  
  4450.     refdef.x = x;
  4451.     refdef.y = y;
  4452.     refdef.width = w;
  4453.     refdef.height = h;
  4454.  
  4455.     DC->modelBounds( item->asset, mins, maxs );
  4456.  
  4457.     origin[2] = -0.5 * ( mins[2] + maxs[2] );
  4458.     origin[1] = 0.5 * ( mins[1] + maxs[1] );
  4459.  
  4460.     // calculate distance so the model nearly fills the box
  4461.     if (qtrue) {
  4462.         float len = 0.5 * ( maxs[2] - mins[2] );        
  4463.         origin[0] = len / 0.268;    // len / tan( fov/2 )
  4464.         //origin[0] = len / tan(w/2);
  4465.     } else {
  4466.         origin[0] = item->textscale;
  4467.     }
  4468.     refdef.fov_x = (modelPtr->fov_x) ? modelPtr->fov_x : w;
  4469.     refdef.fov_y = (modelPtr->fov_y) ? modelPtr->fov_y : h;
  4470.  
  4471.     //refdef.fov_x = (int)((float)refdef.width / 640.0f * 90.0f);
  4472.     //xx = refdef.width / tan( refdef.fov_x / 360 * M_PI );
  4473.     //refdef.fov_y = atan2( refdef.height, xx );
  4474.     //refdef.fov_y *= ( 360 / M_PI );
  4475.  
  4476.     DC->clearScene();
  4477.  
  4478.     refdef.time = DC->realTime;
  4479.  
  4480.     // add the model
  4481.  
  4482.     memset( &ent, 0, sizeof(ent) );
  4483.  
  4484.     //adjust = 5.0 * sin( (float)uis.realtime / 500 );
  4485.     //adjust = 360 % (int)((float)uis.realtime / 1000);
  4486.     //VectorSet( angles, 0, 0, 1 );
  4487.  
  4488.     // use item storage to track
  4489.     if (modelPtr->rotationSpeed) {
  4490.         if (DC->realTime > item->window.nextTime) {
  4491.             item->window.nextTime = DC->realTime + modelPtr->rotationSpeed;
  4492.             modelPtr->angle = (int)(modelPtr->angle + 1) % 360;
  4493.         }
  4494.     }
  4495.     VectorSet( angles, 0, modelPtr->angle, 0 );
  4496.     AnglesToAxis( angles, ent.axis );
  4497.  
  4498.     ent.hModel = item->asset;
  4499.     VectorCopy( origin, ent.origin );
  4500.     VectorCopy( origin, ent.lightingOrigin );
  4501.     ent.renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW;
  4502.     VectorCopy( ent.origin, ent.oldorigin );
  4503.  
  4504.     DC->addRefEntityToScene( &ent );
  4505.     DC->renderScene( &refdef );
  4506.  
  4507. }
  4508.  
  4509.  
  4510. void Item_Image_Paint(itemDef_t *item) {
  4511.     if (item == NULL) {
  4512.         return;
  4513.     }
  4514.     DC->drawHandlePic(item->window.rect.x+1, item->window.rect.y+1, item->window.rect.w-2, item->window.rect.h-2, item->asset);
  4515. }
  4516.  
  4517. void Item_TextScroll_Paint(itemDef_t *item) 
  4518. {
  4519.     float x, y, size, count, thumb;
  4520.     int      i;
  4521.     qhandle_t        optionalImage;
  4522.     textScrollDef_t *scrollPtr;
  4523.  
  4524.     scrollPtr = (textScrollDef_t*)item->typeData;
  4525.  
  4526.     if (item->special && !scrollPtr->lineCount )
  4527.     {
  4528.         item->text = (char *) DC->feederItemText(item->special, 0, 0, &optionalImage);
  4529.  
  4530.         scrollPtr->startPos = 0;
  4531.         scrollPtr->endPos = 0;
  4532.  
  4533.         Item_TextScroll_BuildLines ( item );
  4534.     }
  4535.  
  4536.     count = scrollPtr->lineCount;
  4537.  
  4538.     // draw scrollbar to right side of the window
  4539.     x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE - 1;
  4540.     y = item->window.rect.y + 1;
  4541.     DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowUp);
  4542.     y += SCROLLBAR_SIZE - 1;
  4543.  
  4544.     scrollPtr->endPos = scrollPtr->startPos;
  4545.     size = item->window.rect.h - (SCROLLBAR_SIZE * 2);
  4546.     DC->drawHandlePic(x, y, SCROLLBAR_SIZE, size+1, DC->Assets.scrollBar);
  4547.     y += size - 1;
  4548.     DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowDown);
  4549.     
  4550.     // thumb
  4551.     thumb = Item_TextScroll_ThumbDrawPosition(item);
  4552.     if (thumb > y - SCROLLBAR_SIZE - 1) 
  4553.     {
  4554.         thumb = y - SCROLLBAR_SIZE - 1;
  4555.     }
  4556.     DC->drawHandlePic(x, thumb, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
  4557.  
  4558.     // adjust size for item painting
  4559.     size = item->window.rect.h - 2;
  4560.     x     = item->window.rect.x + 1;
  4561.     y     = item->window.rect.y + 1;
  4562.  
  4563.     for (i = scrollPtr->startPos; i < count; i++) 
  4564.     {
  4565.         char *text;
  4566.  
  4567.         text = scrollPtr->lines[i];
  4568.         if (!text) 
  4569.         {
  4570.             continue;
  4571.         }
  4572.  
  4573.         DC->drawText( 
  4574.             x, 
  4575.             y + item->textaligny, 
  4576.             item->textFont, 
  4577.             item->textscale, 
  4578.             item->window.foreColor, 
  4579.             text, 
  4580.             0, 0 );
  4581.  
  4582.         size -= scrollPtr->lineHeight;
  4583.         if (size < scrollPtr->lineHeight) 
  4584.         {
  4585.             scrollPtr->drawPadding = scrollPtr->lineHeight - size;
  4586.             break;
  4587.         }
  4588.  
  4589.         scrollPtr->endPos++;
  4590.         y += scrollPtr->lineHeight;
  4591.     }
  4592. }
  4593.  
  4594. void Item_ListBox_Paint(itemDef_t *item) 
  4595. {
  4596.     float            x, y, size, count, i, thumb;
  4597.     qhandle_t        image;
  4598.     qhandle_t        optionalImage;
  4599.     listBoxDef_t    *listPtr = (listBoxDef_t*)item->typeData;
  4600.     rectDef_t        rect;
  4601.     const char        *text;
  4602.  
  4603.     rect = item->window.rect;
  4604.  
  4605.     if ( item->type == ITEM_TYPE_COMBOBOX )
  4606.     {
  4607.             // default is vertical if horizontal flag is not here
  4608.         // draw scrollbar to right side of the window
  4609.         x = listPtr->comboRect.x + listPtr->comboRect.w - listPtr->comboRect.h - 1;
  4610.         y = listPtr->comboRect.y;
  4611.         DC->drawHandlePic(x, y, listPtr->comboRect.h, listPtr->comboRect.h, DC->Assets.scrollBarArrowDown);
  4612.         y += listPtr->comboRect.h - 1;
  4613.  
  4614.         // Draw the current text in the combo box
  4615.         x = listPtr->comboRect.x + 4 + item->textalignx;
  4616.         text = DC->feederItemText ( item->special, item->cursorPos, 0, &optionalImage );
  4617.         DC->drawText( x, y + item->textaligny, item->textFont, 
  4618.                       item->textscale, item->window.foreColor, text, 0, 0 );
  4619.  
  4620.         // If the combo box isnt dropped down then enough is rendered
  4621.         if ( !(item->window.flags & WINDOW_DROPPED ) )
  4622.         {
  4623.             return;
  4624.         }
  4625.  
  4626.         DC->drawRect ( rect.x, rect.y + listPtr->elementHeight, rect.w, item->window.border, 1, item->window.borderColor );
  4627.  
  4628.         rect.y += (listPtr->elementHeight + item->window.border);
  4629.         rect.h -= (listPtr->elementHeight + item->window.border);
  4630.     }
  4631.  
  4632.     // the listbox is horizontal or vertical and has a fixed size scroll bar going either direction
  4633.     // elements are enumerated from the DC and either text or image handles are acquired from the DC as well
  4634.     // textscale is used to size the text, textalignx and textaligny are used to size image elements
  4635.     // there is no clipping available so only the last completely visible item is painted
  4636.     count = DC->feederCount(item->special);
  4637.     
  4638.     // default is vertical if horizontal flag is not here
  4639.     if (item->window.flags & WINDOW_HORIZONTAL) 
  4640.     {
  4641.         // draw scrollbar in bottom of the window
  4642.         // bar
  4643.         x = rect.x + 1;
  4644.         y = rect.y + rect.h - SCROLLBAR_SIZE - 1;
  4645.         DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowLeft);
  4646.         x += SCROLLBAR_SIZE - 1;
  4647.         size = rect.w - (SCROLLBAR_SIZE * 2);
  4648.         DC->drawHandlePic(x, y, size+1, SCROLLBAR_SIZE, DC->Assets.scrollBarHoriz);
  4649.         x += size - 1;
  4650.         DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowRight);
  4651.         // thumb
  4652.         thumb = Item_ListBox_ThumbDrawPosition(item);//Item_ListBox_ThumbPosition(item);
  4653.         if (thumb > x - SCROLLBAR_SIZE - 1) {
  4654.             thumb = x - SCROLLBAR_SIZE - 1;
  4655.         }
  4656.         DC->drawHandlePic(thumb, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
  4657.         //
  4658.         listPtr->endPos = listPtr->startPos;
  4659.         size = rect.w - 2;
  4660.         // items
  4661.         // size contains max available space
  4662.         if (listPtr->elementStyle == LISTBOX_IMAGE) {
  4663.             // fit = 0;
  4664.             x = rect.x + 1;
  4665.             y = rect.y + 1;
  4666.             for (i = listPtr->startPos; i < count; i++) {
  4667.                 // always draw at least one
  4668.                 // which may overdraw the box if it is too small for the element
  4669.                 image = DC->feederItemImage(item->special, i);
  4670.                 if (image) {
  4671.                     DC->drawHandlePic(x+1, y+1, listPtr->elementWidth - 2, listPtr->elementHeight - 2, image);
  4672.                 }
  4673.  
  4674.                 if (i == item->cursorPos) {
  4675.                     DC->drawRect(x, y, listPtr->elementWidth-1, listPtr->elementHeight-1, item->window.borderSize, item->window.outlineColor);
  4676.                 }
  4677.  
  4678.                 size -= listPtr->elementWidth;
  4679.                 if (size < listPtr->elementWidth) {
  4680.                     listPtr->drawPadding = size; //listPtr->elementWidth - size;
  4681.                     break;
  4682.                 }
  4683.                 x += listPtr->elementWidth;
  4684.                 listPtr->endPos++;
  4685.                 // fit++;
  4686.             }
  4687.         } else {
  4688.             //
  4689.         }
  4690.  
  4691.         // Endpos is one past the end
  4692.         listPtr->endPos++;
  4693.     } 
  4694.     else 
  4695.     {
  4696.         DC->setColor ( colorWhite );
  4697.  
  4698.         // draw scrollbar to right side of the window
  4699.         x = rect.x + rect.w - SCROLLBAR_SIZE - 1;
  4700.         y = rect.y + 1;
  4701.         DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowUp);
  4702.         y += SCROLLBAR_SIZE - 1;
  4703.  
  4704.         listPtr->endPos = listPtr->startPos;
  4705.         size = rect.h - (SCROLLBAR_SIZE * 2);
  4706.         DC->drawHandlePic(x, y, SCROLLBAR_SIZE, size+1, DC->Assets.scrollBar);
  4707.         y += size - 1;
  4708.         DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowDown);
  4709.         // thumb
  4710.         thumb = Item_ListBox_ThumbDrawPosition(item);//Item_ListBox_ThumbPosition(item);
  4711.         if (thumb > y - SCROLLBAR_SIZE - 1) {
  4712.             thumb = y - SCROLLBAR_SIZE - 1;
  4713.         }
  4714.         DC->drawHandlePic(x, thumb, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
  4715.  
  4716.         // adjust size for item painting
  4717.         size = rect.h - 2;
  4718.         if (listPtr->elementStyle == LISTBOX_IMAGE) {
  4719.             // fit = 0;
  4720.             x = rect.x + 1;
  4721.             y = rect.y + 1;
  4722.             for (i = listPtr->startPos; i < count; i++) {
  4723.                 // always draw at least one
  4724.                 // which may overdraw the box if it is too small for the element
  4725.                 image = DC->feederItemImage(item->special, i);
  4726.                 if (image) {
  4727.                     DC->drawHandlePic(x+1, y+1, listPtr->elementWidth - 2, listPtr->elementHeight - 2, image);
  4728.                 }
  4729.  
  4730.                 if ( item->type == ITEM_TYPE_COMBOBOX )
  4731.                 {
  4732.                     if ( i == listPtr->cursorPos )
  4733.                     {
  4734.                         DC->drawRect(x, y, listPtr->elementWidth - 1, listPtr->elementHeight - 1, item->window.borderSize, item->window.outlineColor);
  4735.                     }
  4736.                 }
  4737.                 else if (i == item->cursorPos) 
  4738.                 {
  4739.                     DC->drawRect(x, y, listPtr->elementWidth - 1, listPtr->elementHeight - 1, item->window.borderSize, item->window.outlineColor);
  4740.                 }
  4741.  
  4742.                 listPtr->endPos++;
  4743.                 size -= listPtr->elementWidth;
  4744.                 if (size < listPtr->elementHeight) {
  4745.                     listPtr->drawPadding = listPtr->elementHeight - size;
  4746.                     break;
  4747.                 }
  4748.                 y += listPtr->elementHeight;
  4749.                 // fit++;
  4750.             }
  4751.         } else {
  4752.             
  4753.             x = rect.x + 1;
  4754.             y = rect.y + 1;
  4755.             
  4756.             for (i = listPtr->startPos; i < count; i++) 
  4757.             {
  4758.                 // always draw at least one
  4759.                 // which may overdraw the box if it is too small for the element
  4760.  
  4761.                 if ( item->type == ITEM_TYPE_COMBOBOX )
  4762.                 {
  4763.                     if ( i == listPtr->cursorPos )
  4764.                     {
  4765.                         DC->fillRect(x + 2, y + 2, rect.w - SCROLLBAR_SIZE - 4, listPtr->elementHeight, item->window.outlineColor);
  4766.                     }
  4767.                 }
  4768.                 else if (i == item->cursorPos) 
  4769.                 {
  4770.                     DC->fillRect(x + 2, y + 2, rect.w - SCROLLBAR_SIZE - 4, listPtr->elementHeight, item->window.outlineColor);
  4771.                 }
  4772.  
  4773.                 if ( listPtr->numColumns > 0 ) 
  4774.                 {
  4775.                     int j;
  4776.                     for (j = 0; j < listPtr->numColumns; j++) 
  4777.                     {
  4778.                         text = DC->feederItemText(item->special, i, j, &optionalImage);
  4779.                         if (optionalImage >= 0) 
  4780.                         {
  4781.                             DC->drawHandlePic(x + 4 + listPtr->columnInfo[j].pos, y - 1 + listPtr->elementHeight / 2, listPtr->columnInfo[j].width, listPtr->columnInfo[j].width, optionalImage);
  4782.                         } 
  4783.                         else if (text) 
  4784.                         {
  4785.                             DC->drawText(x + 4 + listPtr->columnInfo[j].pos + item->textalignx, y + listPtr->elementHeight + item->textaligny, item->textFont, item->textscale, item->window.foreColor, text, listPtr->columnInfo[j].maxChars, 0 );
  4786.                         }
  4787.                     }
  4788.                 } 
  4789.                 else 
  4790.                 {
  4791.                     text = DC->feederItemText(item->special, i, 0, &optionalImage);
  4792.                     if (text) 
  4793.                     {
  4794.                         DC->drawText(x + 4, y + listPtr->elementHeight + item->textaligny, item->textFont, item->textscale, item->window.foreColor, text, 0, 0 );
  4795.                     }
  4796.                 }
  4797.  
  4798.                 listPtr->endPos++;
  4799.  
  4800.                 size -= listPtr->elementHeight;
  4801.                 if (size < listPtr->elementHeight) 
  4802.                 {
  4803.                     listPtr->drawPadding = listPtr->elementHeight - size;
  4804.                     break;
  4805.                 }
  4806.                 y += listPtr->elementHeight;
  4807.                 // fit++;
  4808.             }
  4809.         }
  4810.         // Endpos is one past the end
  4811. //        listPtr->endPos++;
  4812.     }
  4813. }
  4814.  
  4815. void Item_OwnerDraw_Paint(itemDef_t *item) 
  4816. {
  4817.     menuDef_t    *parent;
  4818.     vec4_t        color;
  4819.     vec4_t        lowLight;
  4820.  
  4821.     if (item == NULL) 
  4822.     {
  4823.         return;
  4824.     }
  4825.   
  4826.     parent = (menuDef_t*)item->parent;
  4827.  
  4828.     if (!DC->ownerDrawItem) 
  4829.     {
  4830.         return;
  4831.     }
  4832.  
  4833.     Fade(&item->window.flags, &item->window.foreColor[3], parent->fadeClamp, &item->window.nextTime, parent->fadeCycle, qtrue, parent->fadeAmount);
  4834.     
  4835.     memcpy(&color, &item->window.foreColor, sizeof(color));
  4836.     
  4837.     if (item->numColors > 0 && DC->getValue) 
  4838.     {
  4839.         // if the value is within one of the ranges then set color to that, otherwise leave at default
  4840.         int i;
  4841.         float f = DC->getValue(item->window.ownerDraw);
  4842.     
  4843.         for (i = 0; i < item->numColors; i++) 
  4844.         {
  4845.             if (f >= item->colorRanges[i].low && f <= item->colorRanges[i].high) 
  4846.             {
  4847.                 memcpy(&color, &item->colorRanges[i].color, sizeof(color));
  4848.                 break;
  4849.             }
  4850.         }
  4851.     }
  4852.  
  4853.     if (item->textStyle == ITEM_TEXTSTYLE_BLINK && !((DC->realTime/BLINK_DIVISOR) & 1)) 
  4854.     {
  4855.         lowLight[0] = 0.8 * item->window.foreColor[0]; 
  4856.         lowLight[1] = 0.8 * item->window.foreColor[1]; 
  4857.         lowLight[2] = 0.8 * item->window.foreColor[2]; 
  4858.         lowLight[3] = 0.8 * item->window.foreColor[3]; 
  4859.         LerpColor(item->window.foreColor,lowLight,color,0.5+0.5*sin(DC->realTime / PULSE_DIVISOR));
  4860.     }
  4861.  
  4862.     if ( item->window.flags & WINDOW_DISABLED )
  4863.     {
  4864.         memcpy(color, parent->disableColor, sizeof(vec4_t)); // bk001207 - FIXME: Com_Memcpy
  4865.     }
  4866.     else if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) 
  4867.     {
  4868.         memcpy(color, parent->disableColor, sizeof(vec4_t)); // bk001207 - FIXME: Com_Memcpy
  4869.     }
  4870.     
  4871.     if (item->text) 
  4872.     {
  4873.         Item_Text_Paint(item);
  4874.  
  4875.         if (item->text[0]) 
  4876.         {
  4877.             // +8 is an offset kludge to properly align owner draw items that have text combined with them
  4878.             DC->ownerDrawItem(item->textRect.x + item->textRect.w + 8, item->window.rect.y, item->window.rect.w, item->window.rect.h, 0, item->textaligny, item->window.ownerDraw, item->window.ownerDrawFlags, item->alignment, item->special, item->textFont, item->textscale, color, item->window.background, item->textStyle, item->window.ownerDrawParam );
  4879.         } 
  4880.         else 
  4881.         {
  4882.             DC->ownerDrawItem(item->textRect.x + item->textRect.w, item->window.rect.y, item->window.rect.w, item->window.rect.h, 0, item->textaligny, item->window.ownerDraw, item->window.ownerDrawFlags, item->alignment, item->special, item->textFont, item->textscale, color, item->window.background, item->textStyle, item->window.ownerDrawParam );
  4883.         }
  4884.     } 
  4885.     else 
  4886.     {
  4887.         DC->ownerDrawItem(item->window.rect.x, item->window.rect.y, item->window.rect.w, item->window.rect.h, item->textalignx, item->textaligny, item->window.ownerDraw, item->window.ownerDrawFlags, item->alignment, item->special, item->textFont, item->textscale, color, item->window.background, item->textStyle, item->window.ownerDrawParam );
  4888.     }
  4889. }
  4890.  
  4891.  
  4892. void Item_Paint(itemDef_t *item) 
  4893. {
  4894.     vec4_t        red;
  4895.     menuDef_t *parent = (menuDef_t*)item->parent;
  4896.     int            xPos,textWidth;
  4897.     vec4_t        color = {1, 1, 1, 1};
  4898.     float        origWidth;
  4899.  
  4900.     red[0] = red[3] = 1;
  4901.     red[1] = red[2] = 0;
  4902.  
  4903.     if (item == NULL) 
  4904.     {
  4905.         return;
  4906.     }
  4907.  
  4908.     if (item->window.flags & WINDOW_MOUSEOVER)
  4909.     {
  4910.         if (item->descText)
  4911.         {
  4912.             textWidth = DC->getTextWidth (item->descText, item->textFont, (float) 0.2f, 0 );
  4913.  
  4914.             if (parent->descAlignment == ITEM_ALIGN_RIGHT)
  4915.             {
  4916.                 xPos = parent->descX - textWidth;    // Right justify
  4917.             }
  4918.             else if (parent->descAlignment == ITEM_ALIGN_CENTER)
  4919.             {
  4920.                 xPos = parent->descX - (textWidth/2);    // Center justify
  4921.             }
  4922.             else                                        // Left justify    
  4923.             {
  4924.                 xPos = parent->descX;
  4925.             }
  4926.  
  4927.             Item_TextColor(item, &color);
  4928.             DC->drawText(xPos, parent->descY, item->textFont, (float) 0.2f, parent->descColor, item->descText, 0, 0 );
  4929.         }
  4930.     }
  4931.  
  4932.     if (item->window.flags & WINDOW_ORBITING) 
  4933.     {
  4934.         if (DC->realTime > item->window.nextTime) 
  4935.         {
  4936.             float rx, ry, a, c, s, w, h;
  4937.       
  4938.             item->window.nextTime = DC->realTime + item->window.offsetTime;
  4939.             // translate
  4940.             w = item->window.rectClient.w / 2;
  4941.             h = item->window.rectClient.h / 2;
  4942.             rx = item->window.rectClient.x + w - item->window.rectEffects.x;
  4943.             ry = item->window.rectClient.y + h - item->window.rectEffects.y;
  4944.             a = 3 * M_PI / 180;
  4945.             c = cos(a);
  4946.             s = sin(a);
  4947.             item->window.rectClient.x = (rx * c - ry * s) + item->window.rectEffects.x - w;
  4948.             item->window.rectClient.y = (rx * s + ry * c) + item->window.rectEffects.y - h;
  4949.             Item_UpdatePosition(item);
  4950.         }
  4951.     }
  4952.  
  4953.  
  4954.   if (item->window.flags & WINDOW_INTRANSITION) {
  4955.     if (DC->realTime > item->window.nextTime) {
  4956.       int done = 0;
  4957.       item->window.nextTime = DC->realTime + item->window.offsetTime;
  4958.             // transition the x,y
  4959.             if (item->window.rectClient.x == item->window.rectEffects.x) {
  4960.                 done++;
  4961.             } else {
  4962.                 if (item->window.rectClient.x < item->window.rectEffects.x) {
  4963.                     item->window.rectClient.x += item->window.rectEffects2.x;
  4964.                     if (item->window.rectClient.x > item->window.rectEffects.x) {
  4965.                         item->window.rectClient.x = item->window.rectEffects.x;
  4966.                         done++;
  4967.                     }
  4968.                 } else {
  4969.                     item->window.rectClient.x -= item->window.rectEffects2.x;
  4970.                     if (item->window.rectClient.x < item->window.rectEffects.x) {
  4971.                         item->window.rectClient.x = item->window.rectEffects.x;
  4972.                         done++;
  4973.                     }
  4974.                 }
  4975.             }
  4976.             if (item->window.rectClient.y == item->window.rectEffects.y) {
  4977.                 done++;
  4978.             } else {
  4979.                 if (item->window.rectClient.y < item->window.rectEffects.y) {
  4980.                     item->window.rectClient.y += item->window.rectEffects2.y;
  4981.                     if (item->window.rectClient.y > item->window.rectEffects.y) {
  4982.                         item->window.rectClient.y = item->window.rectEffects.y;
  4983.                         done++;
  4984.                     }
  4985.                 } else {
  4986.                     item->window.rectClient.y -= item->window.rectEffects2.y;
  4987.                     if (item->window.rectClient.y < item->window.rectEffects.y) {
  4988.                         item->window.rectClient.y = item->window.rectEffects.y;
  4989.                         done++;
  4990.                     }
  4991.                 }
  4992.             }
  4993.             if (item->window.rectClient.w == item->window.rectEffects.w) {
  4994.                 done++;
  4995.             } else {
  4996.                 if (item->window.rectClient.w < item->window.rectEffects.w) {
  4997.                     item->window.rectClient.w += item->window.rectEffects2.w;
  4998.                     if (item->window.rectClient.w > item->window.rectEffects.w) {
  4999.                         item->window.rectClient.w = item->window.rectEffects.w;
  5000.                         done++;
  5001.                     }
  5002.                 } else {
  5003.                     item->window.rectClient.w -= item->window.rectEffects2.w;
  5004.                     if (item->window.rectClient.w < item->window.rectEffects.w) {
  5005.                         item->window.rectClient.w = item->window.rectEffects.w;
  5006.                         done++;
  5007.                     }
  5008.                 }
  5009.             }
  5010.             if (item->window.rectClient.h == item->window.rectEffects.h) {
  5011.                 done++;
  5012.             } else {
  5013.                 if (item->window.rectClient.h < item->window.rectEffects.h) {
  5014.                     item->window.rectClient.h += item->window.rectEffects2.h;
  5015.                     if (item->window.rectClient.h > item->window.rectEffects.h) {
  5016.                         item->window.rectClient.h = item->window.rectEffects.h;
  5017.                         done++;
  5018.                     }
  5019.                 } else {
  5020.                     item->window.rectClient.h -= item->window.rectEffects2.h;
  5021.                     if (item->window.rectClient.h < item->window.rectEffects.h) {
  5022.                         item->window.rectClient.h = item->window.rectEffects.h;
  5023.                         done++;
  5024.                     }
  5025.                 }
  5026.             }
  5027.  
  5028.       Item_UpdatePosition(item);
  5029.  
  5030.       if (done == 4) {
  5031.         item->window.flags &= ~WINDOW_INTRANSITION;
  5032.       }
  5033.  
  5034.     }
  5035.   }
  5036.  
  5037.     if (item->window.ownerDrawFlags && DC->ownerDrawVisible) 
  5038.     {
  5039.         int owner = DC->ownerDrawVisible(item->window.ownerDrawFlags, item->window.ownerDrawParam);
  5040.         if ( owner != -1 )
  5041.         {
  5042.             if (!owner) 
  5043.             {
  5044.                 item->window.flags &= ~WINDOW_VISIBLE;
  5045.             } 
  5046.             else 
  5047.             {
  5048.                 item->window.flags |= WINDOW_VISIBLE;
  5049.             }
  5050.         }
  5051.     }
  5052.  
  5053.     if ( item->window.flags & WINDOW_VISIBLE )
  5054.     {
  5055.         if (item->window.ownerDrawFlags && DC->ownerDrawDisabled)
  5056.         {
  5057.             if (!DC->ownerDrawDisabled(item->window.ownerDrawFlags, item->window.ownerDrawParam))
  5058.             {
  5059.                 item->window.flags &= ~WINDOW_DISABLED;
  5060.             }
  5061.             else
  5062.             {
  5063.                 item->window.flags |= WINDOW_DISABLED;
  5064.             }
  5065.         }
  5066.     }
  5067.  
  5068.     if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE)) 
  5069.     {
  5070.         if (!Item_EnableShowViaCvar(item, CVAR_SHOW)) 
  5071.         {
  5072.             return;
  5073.         }
  5074.     }
  5075.  
  5076.     if (!(item->window.flags & WINDOW_VISIBLE)) 
  5077.     {
  5078.         return;
  5079.     }
  5080.  
  5081.     origWidth = item->window.rect.w;
  5082.  
  5083.     // Alter the width of the window if this window is ownerwidth
  5084.     if ( item->window.ownerWidth )
  5085.     {
  5086.         float scale = DC->getValue ( item->window.ownerWidth );
  5087.  
  5088.         // Dont draw the window if the width is zero
  5089.         if ( scale == 0.0f )
  5090.         {
  5091.             return;
  5092.         }
  5093.  
  5094.         // Adjust the width by the percentage returned from getvalue
  5095.         item->window.rect.w *= scale;
  5096.     }
  5097.  
  5098.     // paint the rect first.. 
  5099.     Window_Paint(&item->window, parent->fadeAmount , parent->fadeClamp, parent->fadeCycle);
  5100.  
  5101.   if (debugMode) {
  5102.         vec4_t color;
  5103.         rectDef_t *r = Item_CorrectedTextRect(item);
  5104.     color[1] = color[3] = 1;
  5105.     color[0] = color[2] = 0;
  5106.     DC->drawRect(r->x, r->y, r->w, r->h, 1, color);
  5107.   }
  5108.  
  5109.   //DC->drawRect(item->window.rect.x, item->window.rect.y, item->window.rect.w, item->window.rect.h, 1, red);
  5110.  
  5111.     switch (item->type) 
  5112.     {
  5113.         case ITEM_TYPE_OWNERDRAW:
  5114.             Item_OwnerDraw_Paint(item);
  5115.             break;
  5116.     
  5117.         case ITEM_TYPE_TEXT:
  5118.         case ITEM_TYPE_BUTTON:
  5119.             Item_Text_Paint(item);
  5120.             break;
  5121.     
  5122.         case ITEM_TYPE_RADIOBUTTON:
  5123.             break;
  5124.             
  5125.         case ITEM_TYPE_CHECKBOX:
  5126.             break;
  5127.     
  5128.         case ITEM_TYPE_PASSWORDFIELD:
  5129.         case ITEM_TYPE_EDITFIELD:
  5130.         case ITEM_TYPE_NUMERICFIELD:
  5131.             Item_TextField_Paint(item);
  5132.             break;
  5133.     
  5134.         case ITEM_TYPE_COMBO:
  5135.             break;
  5136.  
  5137.         case ITEM_TYPE_COMBOBOX:
  5138.         case ITEM_TYPE_LISTBOX:
  5139.             Item_ListBox_Paint(item);
  5140.             break;
  5141.  
  5142.         case ITEM_TYPE_TEXTSCROLL:
  5143.             Item_TextScroll_Paint ( item );
  5144.             break;
  5145.  
  5146.         case ITEM_TYPE_MODEL:
  5147.             Item_Model_Paint(item);
  5148.             break;
  5149.     
  5150.         case ITEM_TYPE_YESNO:
  5151.             Item_YesNo_Paint(item);
  5152.             break;
  5153.         
  5154.         case ITEM_TYPE_MULTI:
  5155.             Item_Multi_Paint(item);
  5156.             break;
  5157.     
  5158.         case ITEM_TYPE_BIND:
  5159.             Item_Bind_Paint(item);
  5160.             break;
  5161.     
  5162.         case ITEM_TYPE_SLIDER:
  5163.             Item_Slider_Paint(item);
  5164.             break;
  5165.     
  5166.         default:
  5167.             break;
  5168.   }
  5169.  
  5170.     // Restore the original width of the window incase an owner width window
  5171.     // messed around with it
  5172.     item->window.rect.w = origWidth;
  5173. }
  5174.  
  5175. void Menu_Init(menuDef_t *menu) 
  5176. {
  5177.     memset(menu, 0, sizeof(menuDef_t));
  5178.     menu->cursorItem = -1;
  5179.     menu->fadeAmount = DC->Assets.fadeAmount;
  5180.     menu->fadeClamp = DC->Assets.fadeClamp;
  5181.     menu->fadeCycle = DC->Assets.fadeCycle;
  5182.  
  5183.     // Initialize the tooltip background color
  5184.     menu->tooltipBackColor[0] = 1;
  5185.     menu->tooltipBackColor[1] = 1;
  5186.     menu->tooltipBackColor[2] = 1;
  5187.     menu->tooltipBackColor[3] = 1;
  5188.  
  5189.     // Initialize the tooltip foreground color
  5190.     menu->tooltipForeColor[0] = 0;
  5191.     menu->tooltipForeColor[1] = 0;
  5192.     menu->tooltipForeColor[2] = 0;
  5193.     menu->tooltipForeColor[3] = 1;
  5194.  
  5195.     menu->tooltipScale = 1;
  5196.     menu->tooltipDelay = 500;
  5197.  
  5198.     Window_Init(&menu->window);
  5199. }
  5200.  
  5201. itemDef_t* Menu_GetItemByName ( menuDef_t* menu, const char* name )
  5202. {
  5203.     int i;
  5204.  
  5205.     if ( !menu )
  5206.     {
  5207.         return NULL;
  5208.     }
  5209.  
  5210.     for (i = 0; i < menu->itemCount; i++) 
  5211.     {
  5212.         if ( !Q_stricmp ( menu->items[i]->window.name, name ) )
  5213.         {
  5214.             return menu->items[i];
  5215.         }
  5216.     }
  5217.  
  5218.     return NULL;
  5219. }
  5220.  
  5221. itemDef_t *Menu_GetFocusedItem(menuDef_t *menu) {
  5222.   int i;
  5223.   if (menu) {
  5224.     for (i = 0; i < menu->itemCount; i++) {
  5225.       if (menu->items[i]->window.flags & WINDOW_HASFOCUS) {
  5226.         return menu->items[i];
  5227.       }
  5228.     }
  5229.   }
  5230.   return NULL;
  5231. }
  5232.  
  5233. menuDef_t *Menu_GetFocused() {
  5234.   int i;
  5235.   for (i = 0; i < menuCount; i++) {
  5236.     if (Menus[i].window.flags & WINDOW_HASFOCUS && Menus[i].window.flags & WINDOW_VISIBLE) {
  5237.       return &Menus[i];
  5238.     }
  5239.   }
  5240.   return NULL;
  5241. }
  5242.  
  5243. void Menu_ScrollFeeder(menuDef_t *menu, int feeder, qboolean down) {
  5244.     if (menu) {
  5245.         int i;
  5246.     for (i = 0; i < menu->itemCount; i++) {
  5247.             if (menu->items[i]->special == feeder) {
  5248.                 Item_ListBox_HandleKey(menu->items[i], (down) ? K_DOWNARROW : K_UPARROW, qtrue, qtrue);
  5249.                 return;
  5250.             }
  5251.         }
  5252.     }
  5253. }
  5254.  
  5255.  
  5256.  
  5257. void Menu_SetFeederSelection(menuDef_t *menu, int feeder, int index, const char *name) 
  5258. {
  5259.     if (menu == NULL) 
  5260.     {
  5261.         if (name == NULL) 
  5262.         {
  5263.             menu = Menu_GetFocused();
  5264.         } 
  5265.         else 
  5266.         {
  5267.             menu = Menus_FindByName(name);
  5268.         }
  5269.     }
  5270.  
  5271.     if (menu) 
  5272.     {
  5273.         int i;
  5274.  
  5275.         for (i = 0; i < menu->itemCount; i++) 
  5276.         {
  5277.             if (menu->items[i]->special == feeder) 
  5278.             {
  5279.                 if ( index == 0) 
  5280.                 {
  5281.                     listBoxDef_t *listPtr = (listBoxDef_t*)menu->items[i]->typeData;
  5282.                     listPtr->cursorPos = 0;
  5283.                     listPtr->startPos = 0;
  5284.                 }
  5285.                 menu->items[i]->cursorPos = index;
  5286.                 DC->feederSelection(menu->items[i]->special, menu->items[i]->cursorPos);
  5287.                 return;
  5288.             }
  5289.         }
  5290.     }
  5291. }
  5292.  
  5293. qboolean Menus_AnyFullScreenVisible() {
  5294.   int i;
  5295.   for (i = 0; i < menuCount; i++) {
  5296.     if (Menus[i].window.flags & WINDOW_VISIBLE && Menus[i].fullScreen) {
  5297.             return qtrue;
  5298.     }
  5299.   }
  5300.   return qfalse;
  5301. }
  5302.  
  5303. menuDef_t *Menus_ActivateByName(const char *p) 
  5304. {
  5305.     int          i;
  5306.     menuDef_t *m = NULL;
  5307.     menuDef_t *focus = Menu_GetFocused();
  5308.  
  5309.     // If we find a match for the window then save the pointer, otherwise
  5310.     // clear the focus of the window since the window we are looking 
  5311.     // for will get the focus eventually
  5312.     for (i = 0; i < menuCount; i++) 
  5313.     {
  5314.         if (Q_stricmp(Menus[i].window.name, p) == 0) 
  5315.         {
  5316.             m = &Menus[i];
  5317.         }
  5318.         else 
  5319.         {
  5320.             Menus[i].window.flags &= ~WINDOW_HASFOCUS;
  5321.         }
  5322.     }
  5323.  
  5324.     // make sure the menu was found in the list
  5325.     if ( !m )
  5326.     {
  5327.         return NULL;
  5328.     }
  5329.  
  5330.     // Adjust the menu stack if there was a window with focus already
  5331.     if (openMenuCount < MAX_OPEN_MENUS && focus != NULL ) 
  5332.     {
  5333.         int j;
  5334.  
  5335.         // make sure the menu with focus doenst get in there twice
  5336.         for ( j = 0; j < openMenuCount; j ++ )
  5337.         {
  5338.             if ( menuStack[j] == focus )
  5339.             {
  5340.                 break;
  5341.             }
  5342.         }
  5343.  
  5344.         // If the window isnt already in there somewhere then
  5345.         // add it to the end
  5346.         if ( j >= openMenuCount )
  5347.         {
  5348.             menuStack[openMenuCount++] = focus;
  5349.         }
  5350.     }
  5351.     
  5352.     // Activate the menu
  5353.     Menus_Activate(m);
  5354.         
  5355.     Display_CloseCinematics();
  5356.     
  5357.     return m;
  5358. }
  5359.  
  5360.  
  5361. void Item_Init(itemDef_t *item) {
  5362.     memset(item, 0, sizeof(itemDef_t));
  5363.     item->textscale = 1;
  5364.     Window_Init(&item->window);
  5365. }
  5366.  
  5367. void Menu_HandleMouseMove ( menuDef_t *menu, float x, float y ) 
  5368. {
  5369.     int            i;
  5370.     int            pass;
  5371.     qboolean    focusSet = qfalse;
  5372.  
  5373.     itemDef_t *overItem;
  5374.     if (menu == NULL) 
  5375.     {
  5376.         return;
  5377.     }
  5378.  
  5379.     if (!(menu->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) 
  5380.     {
  5381.         return;
  5382.     }
  5383.  
  5384.     if (itemCapture) 
  5385.     {
  5386.         //Item_MouseMove(itemCapture, x, y);
  5387.         return;
  5388.     }
  5389.  
  5390.     if (g_waitingForKey || g_editingField) 
  5391.     {
  5392.         return;
  5393.     }
  5394.  
  5395.     // FIXME: this is the whole issue of focus vs. mouse over.. 
  5396.     // need a better overall solution as i don't like going through everything twice
  5397.     for (pass = 0; pass < 2; pass++) 
  5398.     {
  5399.         for (i = menu->itemCount - 1; i >= 0 ; i-- ) 
  5400.         {
  5401.             // turn off focus each item
  5402.             // menu->items[i].window.flags &= ~WINDOW_HASFOCUS;
  5403.  
  5404.             if (!(menu->items[i]->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) 
  5405.             {
  5406.                 continue;
  5407.             }
  5408.  
  5409.             if ( menu->items[i]->window.flags & WINDOW_DISABLED )
  5410.             {
  5411.                 continue;
  5412.             }
  5413.  
  5414.             // items can be enabled and disabled based on cvars
  5415.             if (menu->items[i]->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(menu->items[i], CVAR_ENABLE)) {
  5416.                 continue;
  5417.             }
  5418.  
  5419.             if (menu->items[i]->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(menu->items[i], CVAR_SHOW)) {
  5420.                 continue;
  5421.             }
  5422.  
  5423.             if ( (!itemExclusive || itemExclusive == menu->items[i]) && Rect_ContainsPoint(&menu->items[i]->window.rect, x, y)) 
  5424.             {
  5425.                 if (pass == 1) 
  5426.                 {
  5427.                     overItem = menu->items[i];
  5428.                     if (overItem->type == ITEM_TYPE_TEXT && overItem->text) 
  5429.                     {
  5430.                         if (!Rect_ContainsPoint(Item_CorrectedTextRect(overItem), x, y)) 
  5431.                         {
  5432.                             continue;
  5433.                         }
  5434.                     }
  5435.  
  5436.                     // if we are over an item
  5437.                     if (IsVisible(overItem->window.flags) && !(overItem->window.flags&WINDOW_DECORATION) ) 
  5438.                     {
  5439.                         // different one
  5440.                         Item_MouseEnter(overItem, x, y);
  5441.                         // Item_SetMouseOver(overItem, qtrue);
  5442.  
  5443.                         // if item is not a decoration see if it can take focus
  5444.                         if (!focusSet) 
  5445.                         {
  5446.                             focusSet = Item_SetFocus(overItem, x, y);
  5447.  
  5448.                             // Only need one focus item
  5449.                             i = -1;
  5450.                             continue;
  5451.                         }
  5452.                     }
  5453.                 }
  5454.                 else 
  5455.                 {
  5456.                     if ( !(menu->items[i]->window.flags & WINDOW_MOUSEOVER) ) 
  5457.                     {
  5458.                         Item_MouseEnter(menu->items[i], x, y);
  5459.                     }
  5460.                 }
  5461.             } 
  5462.             else if (menu->items[i]->window.flags & WINDOW_MOUSEOVER) 
  5463.             {
  5464.                 Item_MouseLeave(menu->items[i]);
  5465.                 Item_SetMouseOver(menu->items[i], qfalse);
  5466.             }
  5467.         }
  5468.     }
  5469. }
  5470.  
  5471. void Menu_Paint(menuDef_t *menu, qboolean forcePaint) 
  5472. {
  5473.     int i;
  5474.  
  5475.     if (menu == NULL) {
  5476.         return;
  5477.     }
  5478.  
  5479.     if (!(menu->window.flags & WINDOW_VISIBLE) &&  !forcePaint) {
  5480.         return;
  5481.     }
  5482.  
  5483. /*
  5484.     if (menu->window.ownerDrawFlags && DC->ownerDrawVisible && !DC->ownerDrawVisible(menu->window.ownerDrawFlags, menu->window.ownerDrawParam)) 
  5485.     {
  5486.         return;
  5487.     }
  5488. */
  5489.     
  5490.     if (forcePaint) {
  5491.         menu->window.flags |= WINDOW_FORCED;
  5492.     }
  5493.  
  5494.     // draw the background if necessary
  5495.     if (menu->fullScreen) {
  5496.         // implies a background shader
  5497.         // FIXME: make sure we have a default shader if fullscreen is set with no background
  5498.         DC->drawHandlePic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, menu->window.background );
  5499.     } else if (menu->window.background) {
  5500.         // this allows a background shader without being full screen
  5501.         //UI_DrawHandlePic(menu->window.rect.x, menu->window.rect.y, menu->window.rect.w, menu->window.rect.h, menu->backgroundShader);
  5502.     }
  5503.  
  5504.     // paint the background and or border
  5505.     Window_Paint(&menu->window, menu->fadeAmount, menu->fadeClamp, menu->fadeCycle );
  5506.  
  5507.     // Loop through all items for the menu and paint them
  5508.     for (i = 0; i < menu->itemCount; i++) 
  5509.     {
  5510.         if (!menu->items[i]->appearanceSlot)
  5511.         {
  5512.             Item_Paint(menu->items[i]);
  5513.         }
  5514.         else // Timed order of appearance
  5515.         {
  5516.             if (menu->appearanceTime < DC->realTime)    // Time to show another item
  5517.             {
  5518.                 menu->appearanceTime = DC->realTime + menu->appearanceIncrement;
  5519.                 menu->appearanceCnt++;
  5520.             }
  5521.  
  5522.             if (menu->items[i]->appearanceSlot<=menu->appearanceCnt)
  5523.             {
  5524.                 Item_Paint(menu->items[i]);
  5525.             }
  5526.         }
  5527.     }
  5528.  
  5529.     if (debugMode) {
  5530.         vec4_t color;
  5531.         color[0] = color[2] = color[3] = 1;
  5532.         color[1] = 0;
  5533.         DC->drawRect(menu->window.rect.x, menu->window.rect.y, menu->window.rect.w, menu->window.rect.h, 1, color);
  5534.     }
  5535. }
  5536.  
  5537. /*
  5538. ===============
  5539. Item_ValidateTypeData
  5540. ===============
  5541. */
  5542. void Item_ValidateTypeData(itemDef_t *item) 
  5543. {
  5544.     if (item->typeData) 
  5545.     {
  5546.         return;
  5547.     }
  5548.  
  5549.     switch ( item->type )
  5550.     {
  5551.         case ITEM_TYPE_LISTBOX:
  5552.         case ITEM_TYPE_COMBOBOX:
  5553.             item->typeData = trap_VM_LocalAlloc(sizeof(listBoxDef_t));
  5554.             memset(item->typeData, 0, sizeof(listBoxDef_t));
  5555.             break;
  5556.  
  5557.         case ITEM_TYPE_EDITFIELD:
  5558.         case ITEM_TYPE_NUMERICFIELD:
  5559.         case ITEM_TYPE_YESNO:
  5560.         case ITEM_TYPE_BIND:
  5561.         case ITEM_TYPE_SLIDER:
  5562.         case ITEM_TYPE_TEXT:
  5563.         case ITEM_TYPE_PASSWORDFIELD:
  5564.             item->typeData = trap_VM_LocalAlloc(sizeof(editFieldDef_t));
  5565.             memset(item->typeData, 0, sizeof(editFieldDef_t));
  5566.             if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_PASSWORDFIELD) 
  5567.             {
  5568.                 if (!((editFieldDef_t *) item->typeData)->maxPaintChars) 
  5569.                 {
  5570.                     ((editFieldDef_t *) item->typeData)->maxPaintChars = MAX_EDITFIELD;
  5571.                 }
  5572.             }
  5573.             break;
  5574.  
  5575.         case ITEM_TYPE_MULTI:
  5576.             item->typeData = trap_VM_LocalAlloc(sizeof(multiDef_t));
  5577.             break;
  5578.  
  5579.         case ITEM_TYPE_MODEL:
  5580.             item->typeData = trap_VM_LocalAlloc(sizeof(modelDef_t));
  5581.             break;
  5582.  
  5583.         case ITEM_TYPE_TEXTSCROLL:
  5584.             item->typeData = trap_VM_LocalAlloc(sizeof(textScrollDef_t));
  5585.             break;
  5586.     }
  5587. }
  5588.  
  5589. /*
  5590. ===============
  5591. Item Hash
  5592. ===============
  5593. */
  5594.  
  5595. typedef struct itemHash_s
  5596. {
  5597.     keywordHash_t    keyword;
  5598.     qboolean        (*func)(itemDef_t *item, int handle);
  5599.  
  5600. } itemHash_t;
  5601.  
  5602. /*
  5603. ===============
  5604. Item Keyword Parse functions
  5605. ===============
  5606. */
  5607.  
  5608. // name <string>
  5609. qboolean ItemParse_name( itemDef_t *item, int handle ) {
  5610.     if (!PC_String_Parse(handle, &item->window.name)) {
  5611.         return qfalse;
  5612.     }
  5613.     return qtrue;
  5614. }
  5615.  
  5616. // name <string>
  5617. qboolean ItemParse_focusSound( itemDef_t *item, int handle ) {
  5618.     const char *temp;
  5619.     if (!PC_String_Parse(handle, &temp)) {
  5620.         return qfalse;
  5621.     }
  5622.     item->focusSound = DC->registerSound(temp);
  5623.     return qtrue;
  5624. }
  5625.  
  5626.  
  5627. // text <string>
  5628. qboolean ItemParse_text( itemDef_t *item, int handle ) {
  5629.     if (!PC_String_Parse(handle, &item->text)) {
  5630.         return qfalse;
  5631.     }
  5632.     return qtrue;
  5633. }
  5634.  
  5635. /*
  5636. ===============
  5637. ItemParse_descText 
  5638.     text <string>
  5639. ===============
  5640. */
  5641. qboolean ItemParse_descText( itemDef_t *item, int handle) 
  5642. {
  5643.  
  5644.     if (!PC_String_Parse(handle, &item->descText))
  5645.     {
  5646.         return qfalse;
  5647.     }
  5648.  
  5649.     return qtrue;
  5650.  
  5651. }
  5652.  
  5653.  
  5654. /*
  5655. ===============
  5656. ItemParse_text 
  5657.     text <string>
  5658. ===============
  5659. */
  5660. qboolean ItemParse_text2( itemDef_t *item, int handle) 
  5661. {
  5662.  
  5663.     if (!PC_String_Parse(handle, &item->text2))
  5664.     {
  5665.         return qfalse;
  5666.     }
  5667.  
  5668.     return qtrue;
  5669.  
  5670. }
  5671.  
  5672. /*
  5673. ===============
  5674. ItemParse_text2alignx 
  5675. ===============
  5676. */
  5677. qboolean ItemParse_text2alignx( itemDef_t *item, int handle) 
  5678. {
  5679.     if (!PC_Float_Parse(handle, &item->text2alignx)) 
  5680.     {
  5681.         return qfalse;
  5682.     }
  5683.     return qtrue;
  5684. }
  5685.  
  5686. /*
  5687. ===============
  5688. ItemParse_text2aligny 
  5689. ===============
  5690. */
  5691. qboolean ItemParse_text2aligny( itemDef_t *item, int handle) 
  5692. {
  5693.     if (!PC_Float_Parse(handle, &item->text2aligny)) 
  5694.     {
  5695.         return qfalse;
  5696.     }
  5697.     return qtrue;
  5698. }
  5699.  
  5700. // group <string>
  5701. qboolean ItemParse_group( itemDef_t *item, int handle ) {
  5702.     if (!PC_String_Parse(handle, &item->window.group)) {
  5703.         return qfalse;
  5704.     }
  5705.     return qtrue;
  5706. }
  5707.  
  5708. // asset_model <string>
  5709. qboolean ItemParse_asset_model( itemDef_t *item, int handle ) {
  5710.     const char *temp;
  5711.     modelDef_t *modelPtr;
  5712.     Item_ValidateTypeData(item);
  5713.     modelPtr = (modelDef_t*)item->typeData;
  5714.  
  5715.     if (!PC_String_Parse(handle, &temp)) {
  5716.         return qfalse;
  5717.     }
  5718.     item->asset = DC->registerModel(temp);
  5719.     modelPtr->angle = rand() % 360;
  5720.     return qtrue;
  5721. }
  5722.  
  5723. // asset_shader <string>
  5724. qboolean ItemParse_asset_shader( itemDef_t *item, int handle ) {
  5725.     const char *temp;
  5726.  
  5727.     if (!PC_String_Parse(handle, &temp)) {
  5728.         return qfalse;
  5729.     }
  5730.     item->asset = DC->registerShaderNoMip(temp);
  5731.     return qtrue;
  5732. }
  5733.  
  5734. // model_origin <number> <number> <number>
  5735. qboolean ItemParse_model_origin( itemDef_t *item, int handle ) {
  5736.     modelDef_t *modelPtr;
  5737.     Item_ValidateTypeData(item);
  5738.     modelPtr = (modelDef_t*)item->typeData;
  5739.  
  5740.     if (PC_Float_Parse(handle, &modelPtr->origin[0])) {
  5741.         if (PC_Float_Parse(handle, &modelPtr->origin[1])) {
  5742.             if (PC_Float_Parse(handle, &modelPtr->origin[2])) {
  5743.                 return qtrue;
  5744.             }
  5745.         }
  5746.     }
  5747.     return qfalse;
  5748. }
  5749.  
  5750. // model_fovx <number>
  5751. qboolean ItemParse_model_fovx( itemDef_t *item, int handle ) {
  5752.     modelDef_t *modelPtr;
  5753.     Item_ValidateTypeData(item);
  5754.     modelPtr = (modelDef_t*)item->typeData;
  5755.  
  5756.     if (!PC_Float_Parse(handle, &modelPtr->fov_x)) {
  5757.         return qfalse;
  5758.     }
  5759.     return qtrue;
  5760. }
  5761.  
  5762. // model_fovy <number>
  5763. qboolean ItemParse_model_fovy( itemDef_t *item, int handle ) {
  5764.     modelDef_t *modelPtr;
  5765.     Item_ValidateTypeData(item);
  5766.     modelPtr = (modelDef_t*)item->typeData;
  5767.  
  5768.     if (!PC_Float_Parse(handle, &modelPtr->fov_y)) {
  5769.         return qfalse;
  5770.     }
  5771.     return qtrue;
  5772. }
  5773.  
  5774. // model_rotation <integer>
  5775. qboolean ItemParse_model_rotation( itemDef_t *item, int handle ) {
  5776.     modelDef_t *modelPtr;
  5777.     Item_ValidateTypeData(item);
  5778.     modelPtr = (modelDef_t*)item->typeData;
  5779.  
  5780.     if (!PC_Int_Parse(handle, &modelPtr->rotationSpeed)) {
  5781.         return qfalse;
  5782.     }
  5783.     return qtrue;
  5784. }
  5785.  
  5786. // model_angle <integer>
  5787. qboolean ItemParse_model_angle( itemDef_t *item, int handle ) {
  5788.     modelDef_t *modelPtr;
  5789.     Item_ValidateTypeData(item);
  5790.     modelPtr = (modelDef_t*)item->typeData;
  5791.  
  5792.     if (!PC_Int_Parse(handle, &modelPtr->angle)) {
  5793.         return qfalse;
  5794.     }
  5795.     return qtrue;
  5796. }
  5797.  
  5798. // rect <rectangle>
  5799. qboolean ItemParse_rect( itemDef_t *item, int handle ) {
  5800.     if (!PC_Rect_Parse(handle, &item->window.rectClient)) {
  5801.         return qfalse;
  5802.     }
  5803.     return qtrue;
  5804. }
  5805.  
  5806. /*
  5807. ===============
  5808. ItemParse_flag
  5809.     style <integer>
  5810. ===============
  5811. */
  5812. qboolean ItemParse_flag( itemDef_t *item, int handle) 
  5813. {
  5814.     int        i;
  5815.     const char    *tempStr;
  5816.  
  5817.     if (!PC_String_Parse(handle, &tempStr))
  5818.     {
  5819.         return qfalse;
  5820.     }
  5821.  
  5822.     i=0;
  5823.     while (styles[i])
  5824.     {
  5825.         if (Q_stricmp(tempStr,itemFlags[i].string)==0)
  5826.         {
  5827.             item->window.flags |= itemFlags[i].value;
  5828.             break;
  5829.         }
  5830.         i++;
  5831.     }
  5832.  
  5833.     if (itemFlags[i].string == NULL)
  5834.     {
  5835.         Com_Printf(va(S_COLOR_YELLOW "Unknown item style value '%s'",tempStr));
  5836.     }
  5837.  
  5838.     return qtrue;
  5839. }
  5840.  
  5841. /*
  5842. ===============
  5843. ItemParse_style 
  5844.     style <integer>
  5845. ===============
  5846. */
  5847. qboolean ItemParse_style( itemDef_t *item, int handle) 
  5848. {
  5849.     if (!PC_Int_Parse(handle, &item->window.style))
  5850.     {
  5851.         Com_Printf(S_COLOR_YELLOW "Unknown item style value");
  5852.         return qfalse;
  5853.     }
  5854.  
  5855.     return qtrue;
  5856. }
  5857.  
  5858.  
  5859. // decoration
  5860. qboolean ItemParse_decoration( itemDef_t *item, int handle ) {
  5861.     item->window.flags |= WINDOW_DECORATION;
  5862.     return qtrue;
  5863. }
  5864.  
  5865. // notselectable
  5866. qboolean ItemParse_notselectable( itemDef_t *item, int handle ) {
  5867.     listBoxDef_t *listPtr;
  5868.     Item_ValidateTypeData(item);
  5869.     listPtr = (listBoxDef_t*)item->typeData;
  5870.     if (item->type == ITEM_TYPE_LISTBOX && listPtr) {
  5871.         listPtr->notselectable = qtrue;
  5872.     }
  5873.     return qtrue;
  5874. }
  5875.  
  5876. // manually wrapped
  5877. qboolean ItemParse_wrapped( itemDef_t *item, int handle ) {
  5878.     item->window.flags |= WINDOW_WRAPPED;
  5879.     return qtrue;
  5880. }
  5881.  
  5882. // auto wrapped
  5883. qboolean ItemParse_autowrapped( itemDef_t *item, int handle ) {
  5884.     item->window.flags |= WINDOW_AUTOWRAPPED;
  5885.     return qtrue;
  5886. }
  5887.  
  5888.  
  5889. // horizontalscroll
  5890. qboolean ItemParse_horizontalscroll( itemDef_t *item, int handle ) {
  5891.     item->window.flags |= WINDOW_HORIZONTAL;
  5892.     return qtrue;
  5893. }
  5894.  
  5895. /*
  5896. ===============
  5897. ItemParse_type 
  5898.     type <integer>
  5899. ===============
  5900. */
  5901. qboolean ItemParse_type( itemDef_t *item, int handle  ) 
  5902. {
  5903. //    int        i,holdInt;
  5904.  
  5905.     if (!PC_Int_Parse(handle, &item->type)) 
  5906.     {
  5907.         return qfalse;
  5908.     }
  5909.     Item_ValidateTypeData(item);
  5910.     return qtrue;
  5911. }
  5912.  
  5913. // elementwidth, used for listbox image elements
  5914. // uses textalignx for storage
  5915. qboolean ItemParse_elementwidth( itemDef_t *item, int handle ) {
  5916.     listBoxDef_t *listPtr;
  5917.  
  5918.     Item_ValidateTypeData(item);
  5919.     listPtr = (listBoxDef_t*)item->typeData;
  5920.     if (!PC_Float_Parse(handle, &listPtr->elementWidth)) {
  5921.         return qfalse;
  5922.     }
  5923.     return qtrue;
  5924. }
  5925.  
  5926. // elementheight, used for listbox image elements
  5927. // uses textaligny for storage
  5928. qboolean ItemParse_elementheight( itemDef_t *item, int handle ) {
  5929.     listBoxDef_t *listPtr;
  5930.  
  5931.     Item_ValidateTypeData(item);
  5932.     listPtr = (listBoxDef_t*)item->typeData;
  5933.     if (!PC_Float_Parse(handle, &listPtr->elementHeight)) {
  5934.         return qfalse;
  5935.     }
  5936.     return qtrue;
  5937. }
  5938.  
  5939. // feeder <float>
  5940. qboolean ItemParse_feeder( itemDef_t *item, int handle ) {
  5941.     if (!PC_Float_Parse(handle, &item->special)) {
  5942.         return qfalse;
  5943.     }
  5944.     return qtrue;
  5945. }
  5946.  
  5947. // elementtype, used to specify what type of elements a listbox contains
  5948. // uses textstyle for storage
  5949. qboolean ItemParse_elementtype( itemDef_t *item, int handle ) {
  5950.     listBoxDef_t *listPtr;
  5951.  
  5952.     Item_ValidateTypeData(item);
  5953.     if (!item->typeData)
  5954.         return qfalse;
  5955.     listPtr = (listBoxDef_t*)item->typeData;
  5956.     if (!PC_Int_Parse(handle, &listPtr->elementStyle)) {
  5957.         return qfalse;
  5958.     }
  5959.     return qtrue;
  5960. }
  5961.  
  5962. // columns sets a number of columns and an x pos and width per.. 
  5963. qboolean ItemParse_columns( itemDef_t *item, int handle ) {
  5964.     int num, i;
  5965.     listBoxDef_t *listPtr;
  5966.  
  5967.     Item_ValidateTypeData(item);
  5968.     if (!item->typeData)
  5969.         return qfalse;
  5970.     listPtr = (listBoxDef_t*)item->typeData;
  5971.     if (PC_Int_Parse(handle, &num)) {
  5972.         if (num > MAX_LB_COLUMNS) {
  5973.             num = MAX_LB_COLUMNS;
  5974.         }
  5975.         listPtr->numColumns = num;
  5976.         for (i = 0; i < num; i++) {
  5977.             int pos, width, maxChars;
  5978.  
  5979.             if (PC_Int_Parse(handle, &pos) && PC_Int_Parse(handle, &width) && PC_Int_Parse(handle, &maxChars)) {
  5980.                 listPtr->columnInfo[i].pos = pos;
  5981.                 listPtr->columnInfo[i].width = width;
  5982.                 listPtr->columnInfo[i].maxChars = maxChars;
  5983.             } else {
  5984.                 return qfalse;
  5985.             }
  5986.         }
  5987.     } else {
  5988.         return qfalse;
  5989.     }
  5990.     return qtrue;
  5991. }
  5992.  
  5993. qboolean ItemParse_border( itemDef_t *item, int handle ) {
  5994.     if (!PC_Int_Parse(handle, &item->window.border)) {
  5995.         return qfalse;
  5996.     }
  5997.     return qtrue;
  5998. }
  5999.  
  6000. qboolean ItemParse_bordersize( itemDef_t *item, int handle ) {
  6001.     if (!PC_Float_Parse(handle, &item->window.borderSize)) {
  6002.         return qfalse;
  6003.     }
  6004.     return qtrue;
  6005. }
  6006.  
  6007. qboolean ItemParse_visible( itemDef_t *item, int handle ) {
  6008.     int i;
  6009.  
  6010.     if (!PC_Int_Parse(handle, &i)) {
  6011.         return qfalse;
  6012.     }
  6013.     if (i) {
  6014.         item->window.flags |= WINDOW_VISIBLE;
  6015.     }
  6016.     return qtrue;
  6017. }
  6018.  
  6019. qboolean ItemParse_ownerdraw( itemDef_t *item, int handle ) {
  6020.     if (!PC_Int_Parse(handle, &item->window.ownerDraw)) {
  6021.         return qfalse;
  6022.     }
  6023.     item->type = ITEM_TYPE_OWNERDRAW;
  6024.     return qtrue;
  6025. }
  6026.  
  6027. qboolean ItemParse_ownerwidth( itemDef_t *item, int handle ) 
  6028. {
  6029.     if (!PC_Int_Parse(handle, &item->window.ownerWidth)) 
  6030.     {
  6031.         return qfalse;
  6032.     }
  6033.  
  6034.     return qtrue;
  6035. }
  6036.  
  6037. qboolean ItemParse_align( itemDef_t *item, int handle ) {
  6038.     if (!PC_Int_Parse(handle, &item->alignment)) {
  6039.         return qfalse;
  6040.     }
  6041.     return qtrue;
  6042. }
  6043.  
  6044. /*
  6045. ===============
  6046. ItemParse_textalign 
  6047. ===============
  6048. */
  6049. qboolean ItemParse_textalign( itemDef_t *item, int handle ) 
  6050. {
  6051.     if (!PC_Int_Parse(handle, &item->textalignment)) 
  6052.     {
  6053.         Com_Printf(S_COLOR_YELLOW "Unknown text alignment value");
  6054.         return qfalse;
  6055.     }
  6056.  
  6057.     return qtrue;
  6058.  
  6059. }
  6060.  
  6061. qboolean ItemParse_textalignx( itemDef_t *item, int handle ) {
  6062.     if (!PC_Float_Parse(handle, &item->textalignx)) {
  6063.         return qfalse;
  6064.     }
  6065.     return qtrue;
  6066. }
  6067.  
  6068. qboolean ItemParse_textaligny( itemDef_t *item, int handle ) {
  6069.     if (!PC_Float_Parse(handle, &item->textaligny)) {
  6070.         return qfalse;
  6071.     }
  6072.     return qtrue;
  6073. }
  6074.  
  6075. qboolean ItemParse_textscale( itemDef_t *item, int handle ) {
  6076.     if (!PC_Float_Parse(handle, &item->textscale)) {
  6077.         return qfalse;
  6078.     }
  6079.     return qtrue;
  6080. }
  6081.  
  6082. qboolean ItemParse_textstyle( itemDef_t *item, int handle ) {
  6083.     if (!PC_Int_Parse(handle, &item->textStyle)) {
  6084.         return qfalse;
  6085.     }
  6086.     return qtrue;
  6087. }
  6088.  
  6089. qboolean ItemParse_textfont( itemDef_t *item, int handle ) 
  6090. {
  6091.     const char* fontName;
  6092.  
  6093.     if (!PC_String_Parse(handle, &fontName) )
  6094.     {
  6095.         return qfalse;
  6096.     }
  6097.  
  6098.     item->textFont = DC->registerFont ( fontName );
  6099.  
  6100.     return qtrue;
  6101. }
  6102.  
  6103. qboolean ItemParse_backcolor( itemDef_t *item, int handle ) {
  6104.     int i;
  6105.     float f;
  6106.  
  6107.     for (i = 0; i < 4; i++) {
  6108.         if (!PC_Float_Parse(handle, &f)) {
  6109.             return qfalse;
  6110.         }
  6111.         item->window.backColor[i]  = f;
  6112.     }
  6113.     return qtrue;
  6114. }
  6115.  
  6116. qboolean ItemParse_forecolor( itemDef_t *item, int handle ) {
  6117.     int i;
  6118.     float f;
  6119.  
  6120.     for (i = 0; i < 4; i++) {
  6121.         if (!PC_Float_Parse(handle, &f)) {
  6122.             return qfalse;
  6123.         }
  6124.         item->window.foreColor[i]  = f;
  6125.         item->window.flags |= WINDOW_FORECOLORSET;
  6126.     }
  6127.     return qtrue;
  6128. }
  6129.  
  6130. qboolean ItemParse_bordercolor( itemDef_t *item, int handle ) {
  6131.     int i;
  6132.     float f;
  6133.  
  6134.     for (i = 0; i < 4; i++) {
  6135.         if (!PC_Float_Parse(handle, &f)) {
  6136.             return qfalse;
  6137.         }
  6138.         item->window.borderColor[i]  = f;
  6139.     }
  6140.     return qtrue;
  6141. }
  6142.  
  6143. qboolean ItemParse_outlinecolor( itemDef_t *item, int handle ) {
  6144.     if (!PC_Color_Parse(handle, &item->window.outlineColor)){
  6145.         return qfalse;
  6146.     }
  6147.     return qtrue;
  6148. }
  6149.  
  6150. qboolean ItemParse_background( itemDef_t *item, int handle ) {
  6151.     const char *temp;
  6152.  
  6153.     if (!PC_String_Parse(handle, &temp)) {
  6154.         return qfalse;
  6155.     }
  6156.     item->window.background = DC->registerShaderNoMip(temp);
  6157.     return qtrue;
  6158. }
  6159.  
  6160. qboolean ItemParse_cinematic( itemDef_t *item, int handle ) {
  6161.     if (!PC_String_Parse(handle, &item->window.cinematicName)) {
  6162.         return qfalse;
  6163.     }
  6164.     return qtrue;
  6165. }
  6166.  
  6167. qboolean ItemParse_doubleClick( itemDef_t *item, int handle ) {
  6168.     listBoxDef_t *listPtr;
  6169.  
  6170.     Item_ValidateTypeData(item);
  6171.     if (!item->typeData) {
  6172.         return qfalse;
  6173.     }
  6174.  
  6175.     listPtr = (listBoxDef_t*)item->typeData;
  6176.  
  6177.     if (!PC_Script_Parse(handle, &listPtr->doubleClick)) {
  6178.         return qfalse;
  6179.     }
  6180.     return qtrue;
  6181. }
  6182.  
  6183. qboolean ItemParse_hotKey ( itemDef_t* item, int handle ) {
  6184.     const char *temp;
  6185.     if (!PC_String_Parse(handle, &temp)) {
  6186.         return qfalse;
  6187.     }
  6188.  
  6189.     item->hotKey = temp[0];
  6190.  
  6191.     return qtrue;
  6192. }
  6193.  
  6194. qboolean ItemParse_onFocus( itemDef_t *item, int handle ) {
  6195.     if (!PC_Script_Parse(handle, &item->onFocus)) {
  6196.         return qfalse;
  6197.     }
  6198.     return qtrue;
  6199. }
  6200.  
  6201. qboolean ItemParse_leaveFocus( itemDef_t *item, int handle ) {
  6202.     if (!PC_Script_Parse(handle, &item->leaveFocus)) {
  6203.         return qfalse;
  6204.     }
  6205.     return qtrue;
  6206. }
  6207.  
  6208. qboolean ItemParse_mouseEnter( itemDef_t *item, int handle ) {
  6209.     if (!PC_Script_Parse(handle, &item->mouseEnter)) {
  6210.         return qfalse;
  6211.     }
  6212.     return qtrue;
  6213. }
  6214.  
  6215. qboolean ItemParse_mouseExit( itemDef_t *item, int handle ) {
  6216.     if (!PC_Script_Parse(handle, &item->mouseExit)) {
  6217.         return qfalse;
  6218.     }
  6219.     return qtrue;
  6220. }
  6221.  
  6222. qboolean ItemParse_mouseEnterText( itemDef_t *item, int handle ) {
  6223.     if (!PC_Script_Parse(handle, &item->mouseEnterText)) {
  6224.         return qfalse;
  6225.     }
  6226.     return qtrue;
  6227. }
  6228.  
  6229. qboolean ItemParse_mouseExitText( itemDef_t *item, int handle ) {
  6230.     if (!PC_Script_Parse(handle, &item->mouseExitText)) {
  6231.         return qfalse;
  6232.     }
  6233.     return qtrue;
  6234. }
  6235.  
  6236. qboolean ItemParse_action( itemDef_t *item, int handle ) {
  6237.     if (!PC_Script_Parse(handle, &item->action)) {
  6238.         return qfalse;
  6239.     }
  6240.     return qtrue;
  6241. }
  6242.  
  6243. qboolean ItemParse_special( itemDef_t *item, int handle ) {
  6244.     if (!PC_Float_Parse(handle, &item->special)) {
  6245.         return qfalse;
  6246.     }
  6247.     return qtrue;
  6248. }
  6249.  
  6250. qboolean ItemParse_cvarTest( itemDef_t *item, int handle ) {
  6251.     if (!PC_String_Parse(handle, &item->cvarTest)) {
  6252.         return qfalse;
  6253.     }
  6254.     return qtrue;
  6255. }
  6256.  
  6257. qboolean ItemParse_cvar( itemDef_t *item, int handle ) {
  6258.     editFieldDef_t *editPtr;
  6259.  
  6260.     Item_ValidateTypeData(item);
  6261.     if (!PC_String_Parse(handle, &item->cvar)) {
  6262.         return qfalse;
  6263.     }
  6264.     if (item->typeData) {
  6265.         editPtr = (editFieldDef_t*)item->typeData;
  6266.         editPtr->minVal = -1;
  6267.         editPtr->maxVal = -1;
  6268.         editPtr->defVal = -1;
  6269.     }
  6270.     return qtrue;
  6271. }
  6272.  
  6273. qboolean ItemParse_maxChars( itemDef_t *item, int handle ) {
  6274.     editFieldDef_t *editPtr;
  6275.     int maxChars;
  6276.  
  6277.     Item_ValidateTypeData(item);
  6278.     if (!item->typeData)
  6279.         return qfalse;
  6280.  
  6281.     if (!PC_Int_Parse(handle, &maxChars)) {
  6282.         return qfalse;
  6283.     }
  6284.     editPtr = (editFieldDef_t*)item->typeData;
  6285.     editPtr->maxChars = maxChars;
  6286.     return qtrue;
  6287. }
  6288.  
  6289. qboolean ItemParse_maxPaintChars( itemDef_t *item, int handle ) {
  6290.     editFieldDef_t *editPtr;
  6291.     int maxChars;
  6292.  
  6293.     Item_ValidateTypeData(item);
  6294.     if (!item->typeData)
  6295.         return qfalse;
  6296.  
  6297.     if (!PC_Int_Parse(handle, &maxChars)) {
  6298.         return qfalse;
  6299.     }
  6300.     editPtr = (editFieldDef_t*)item->typeData;
  6301.     editPtr->maxPaintChars = maxChars;
  6302.     return qtrue;
  6303. }
  6304.  
  6305.  
  6306.  
  6307. qboolean ItemParse_maxLineChars( itemDef_t *item, int handle ) 
  6308. {
  6309.     textScrollDef_t *scrollPtr;
  6310.     int                maxChars;
  6311.  
  6312.     Item_ValidateTypeData(item);
  6313.     if (!item->typeData)
  6314.         return qfalse;
  6315.  
  6316.     if (!PC_Int_Parse(handle, &maxChars)) 
  6317.     {
  6318.         return qfalse;
  6319.     }
  6320.  
  6321.     scrollPtr = (textScrollDef_t*)item->typeData;
  6322.     scrollPtr->maxLineChars = maxChars;
  6323.  
  6324.     return qtrue;
  6325. }
  6326.  
  6327. qboolean ItemParse_lineHeight( itemDef_t *item, int handle ) 
  6328. {
  6329.     textScrollDef_t *scrollPtr;
  6330.     int                height;
  6331.  
  6332.     Item_ValidateTypeData(item);
  6333.     if (!item->typeData)
  6334.         return qfalse;
  6335.  
  6336.     if (!PC_Int_Parse(handle, &height)) 
  6337.     {
  6338.         return qfalse;
  6339.     }
  6340.  
  6341.     scrollPtr = (textScrollDef_t*)item->typeData;
  6342.     scrollPtr->lineHeight = height;
  6343.  
  6344.     return qtrue;
  6345. }
  6346.  
  6347. qboolean ItemParse_cvarFloat( itemDef_t *item, int handle ) {
  6348.     editFieldDef_t *editPtr;
  6349.  
  6350.     Item_ValidateTypeData(item);
  6351.     if (!item->typeData)
  6352.         return qfalse;
  6353.     editPtr = (editFieldDef_t*)item->typeData;
  6354.     if (PC_String_Parse(handle, &item->cvar) &&
  6355.         PC_Float_Parse(handle, &editPtr->defVal) &&
  6356.         PC_Float_Parse(handle, &editPtr->minVal) &&
  6357.         PC_Float_Parse(handle, &editPtr->maxVal)) {
  6358.         return qtrue;
  6359.     }
  6360.     return qfalse;
  6361. }
  6362.  
  6363. qboolean ItemParse_cvarStrList( itemDef_t *item, int handle ) {
  6364.     pc_token_t token;
  6365.     multiDef_t *multiPtr;
  6366.     int pass;
  6367.     
  6368.     Item_ValidateTypeData(item);
  6369.     if (!item->typeData)
  6370.         return qfalse;
  6371.     multiPtr = (multiDef_t*)item->typeData;
  6372.     multiPtr->count = 0;
  6373.     multiPtr->strDef = qtrue;
  6374.  
  6375.     if (!trap_PC_ReadToken(handle, &token))
  6376.         return qfalse;
  6377.     if (*token.string != '{') {
  6378.         return qfalse;
  6379.     }
  6380.  
  6381.     pass = 0;
  6382.     while ( 1 ) {
  6383.         if (!trap_PC_ReadToken(handle, &token)) {
  6384.             PC_SourceError(handle, "end of file inside menu item\n");
  6385.             return qfalse;
  6386.         }
  6387.  
  6388.         if (*token.string == '}') {
  6389.             return qtrue;
  6390.         }
  6391.  
  6392.         if (*token.string == ',' || *token.string == ';') {
  6393.             continue;
  6394.         }
  6395.  
  6396.         if (pass == 0) {
  6397.             multiPtr->cvarList[multiPtr->count] = String_Alloc(token.string);
  6398.             pass = 1;
  6399.         } else {
  6400.             multiPtr->cvarStr[multiPtr->count] = String_Alloc(token.string);
  6401.             pass = 0;
  6402.             multiPtr->count++;
  6403.             if (multiPtr->count >= MAX_MULTI_CVARS) {
  6404.                 return qfalse;
  6405.             }
  6406.         }
  6407.  
  6408.     }
  6409.     return qfalse;     // bk001205 - LCC missing return value
  6410. }
  6411.  
  6412. qboolean ItemParse_cvarFloatList( itemDef_t *item, int handle ) {
  6413.     pc_token_t token;
  6414.     multiDef_t *multiPtr;
  6415.     
  6416.     Item_ValidateTypeData(item);
  6417.     if (!item->typeData)
  6418.         return qfalse;
  6419.     multiPtr = (multiDef_t*)item->typeData;
  6420.     multiPtr->count = 0;
  6421.     multiPtr->strDef = qfalse;
  6422.  
  6423.     if (!trap_PC_ReadToken(handle, &token))
  6424.         return qfalse;
  6425.     if (*token.string != '{') {
  6426.         return qfalse;
  6427.     }
  6428.  
  6429.     while ( 1 ) {
  6430.         if (!trap_PC_ReadToken(handle, &token)) {
  6431.             PC_SourceError(handle, "end of file inside menu item\n");
  6432.             return qfalse;
  6433.         }
  6434.  
  6435.         if (*token.string == '}') {
  6436.             return qtrue;
  6437.         }
  6438.  
  6439.         if (*token.string == ',' || *token.string == ';') {
  6440.             continue;
  6441.         }
  6442.  
  6443.         multiPtr->cvarList[multiPtr->count] = String_Alloc(token.string);
  6444.         if (!PC_Float_Parse(handle, &multiPtr->cvarValue[multiPtr->count])) {
  6445.             return qfalse;
  6446.         }
  6447.  
  6448.         multiPtr->count++;
  6449.         if (multiPtr->count >= MAX_MULTI_CVARS) {
  6450.             return qfalse;
  6451.         }
  6452.  
  6453.     }
  6454.     return qfalse;     // bk001205 - LCC missing return value
  6455. }
  6456.  
  6457.  
  6458.  
  6459. qboolean ItemParse_addColorRange( itemDef_t *item, int handle ) {
  6460.     colorRangeDef_t color;
  6461.  
  6462.     if (PC_Float_Parse(handle, &color.low) &&
  6463.         PC_Float_Parse(handle, &color.high) &&
  6464.         PC_Color_Parse(handle, &color.color) ) {
  6465.         if (item->numColors < MAX_COLOR_RANGES) {
  6466.             memcpy(&item->colorRanges[item->numColors], &color, sizeof(color));
  6467.             item->numColors++;
  6468.         }
  6469.         return qtrue;
  6470.     }
  6471.     return qfalse;
  6472. }
  6473.  
  6474. qboolean ItemParse_ownerdrawFlag( itemDef_t *item, int handle ) 
  6475. {
  6476.     int i;
  6477.     if (!PC_Int_Parse(handle, &i)) 
  6478.     {
  6479.         return qfalse;
  6480.     }
  6481.     item->window.ownerDrawFlags |= i;
  6482.     return qtrue;
  6483. }
  6484.  
  6485. qboolean ItemParse_ownerdrawParam ( itemDef_t* item, int handle )
  6486. {
  6487.     if ( !PC_String_Parse ( handle, &item->window.ownerDrawParam ) )
  6488.     {
  6489.         return qfalse;
  6490.     }
  6491.  
  6492.     return qtrue;
  6493. }
  6494.  
  6495. qboolean ItemParse_enableCvar( itemDef_t *item, int handle ) {
  6496.     if (PC_Script_Parse(handle, &item->enableCvar)) {
  6497.         item->cvarFlags = CVAR_ENABLE;
  6498.         return qtrue;
  6499.     }
  6500.     return qfalse;
  6501. }
  6502.  
  6503. qboolean ItemParse_disableCvar( itemDef_t *item, int handle ) {
  6504.     if (PC_Script_Parse(handle, &item->enableCvar)) {
  6505.         item->cvarFlags = CVAR_DISABLE;
  6506.         return qtrue;
  6507.     }
  6508.     return qfalse;
  6509. }
  6510.  
  6511. qboolean ItemParse_showCvar( itemDef_t *item, int handle ) {
  6512.     if (PC_Script_Parse(handle, &item->enableCvar)) {
  6513.         item->cvarFlags = CVAR_SHOW;
  6514.         return qtrue;
  6515.     }
  6516.     return qfalse;
  6517. }
  6518.  
  6519. qboolean ItemParse_hideCvar( itemDef_t *item, int handle ) {
  6520.     if (PC_Script_Parse(handle, &item->enableCvar)) {
  6521.         item->cvarFlags = CVAR_HIDE;
  6522.         return qtrue;
  6523.     }
  6524.     return qfalse;
  6525. }
  6526.  
  6527. /*
  6528. ===============
  6529. ItemParse_align 
  6530. ===============
  6531. */
  6532. qboolean ItemParse_Appearance_slot( itemDef_t *item, int handle ) 
  6533. {
  6534.     if (!PC_Int_Parse(handle, &item->appearanceSlot))
  6535.     {
  6536.         return qfalse;
  6537.     }
  6538.     return qtrue;
  6539. }
  6540.  
  6541.  
  6542. /*
  6543. ===============
  6544. ItemParse_tooltip 
  6545. ===============
  6546. */
  6547. qboolean ItemParse_tooltip ( itemDef_t *item, int handle ) 
  6548. {
  6549.     if (!PC_String_Parse(handle, &item->tooltip))
  6550.     {
  6551.         return qfalse;
  6552.     }
  6553.  
  6554.     return qtrue;
  6555. }
  6556.  
  6557. itemHash_t itemParseKeywords[] = {
  6558.     {{"action",                NULL },        ItemParse_action            },
  6559.     {{"addColorRange",        NULL },        ItemParse_addColorRange        },
  6560.     {{"align",                NULL },        ItemParse_align                },
  6561.     {{"autowrapped",        NULL },        ItemParse_autowrapped        },
  6562.     {{"appearance_slot",    NULL },        ItemParse_Appearance_slot    },
  6563.     {{"asset_model",        NULL },        ItemParse_asset_model        },
  6564.     {{"asset_shader",        NULL },        ItemParse_asset_shader        },
  6565.     {{"backcolor",            NULL },        ItemParse_backcolor            },
  6566.     {{"background",            NULL },        ItemParse_background        },
  6567.     {{"border",                NULL },        ItemParse_border            },
  6568.     {{"bordercolor",        NULL },        ItemParse_bordercolor        },
  6569.     {{"bordersize",            NULL },        ItemParse_bordersize        },
  6570.     {{"cinematic",            NULL },        ItemParse_cinematic            },
  6571.     {{"columns",            NULL },        ItemParse_columns            },
  6572.     {{"cvar",                NULL },        ItemParse_cvar                },
  6573.     {{"cvarFloat",            NULL },        ItemParse_cvarFloat            },
  6574.     {{"cvarFloatList",        NULL },        ItemParse_cvarFloatList        },
  6575.     {{"cvarStrList",        NULL },        ItemParse_cvarStrList        },
  6576.     {{"cvarTest",            NULL },        ItemParse_cvarTest            },
  6577.     {{"desctext",            NULL },        ItemParse_descText            },
  6578.     {{"decoration",            NULL },        ItemParse_decoration        },
  6579.     {{"disableCvar",        NULL },        ItemParse_disableCvar        },
  6580.     {{"doubleclick",        NULL },        ItemParse_doubleClick        },
  6581.     {{"elementheight",        NULL },        ItemParse_elementheight        },
  6582.     {{"elementtype",        NULL },        ItemParse_elementtype        },
  6583.     {{"elementwidth",        NULL },        ItemParse_elementwidth        },
  6584.     {{"enableCvar",            NULL },        ItemParse_enableCvar        },
  6585.     {{"feeder",                NULL },        ItemParse_feeder            },
  6586.     {{"flag",                NULL },        ItemParse_flag                },
  6587.     {{"focusSound",            NULL },        ItemParse_focusSound        },
  6588.     {{"forecolor",            NULL },        ItemParse_forecolor            },
  6589.     {{"group",                NULL },        ItemParse_group                },
  6590.     {{"hideCvar",            NULL },        ItemParse_hideCvar            },
  6591.     {{"horizontalscroll",    NULL },        ItemParse_horizontalscroll    },
  6592.     {{"leaveFocus",            NULL },        ItemParse_leaveFocus        },
  6593.     {{"maxChars",            NULL },        ItemParse_maxChars            },
  6594.     {{"maxPaintChars",        NULL },        ItemParse_maxPaintChars        },
  6595.     {{"model_angle",        NULL },        ItemParse_model_angle        },
  6596.     {{"model_fovx",            NULL },        ItemParse_model_fovx        },
  6597.     {{"model_fovy",            NULL },        ItemParse_model_fovy        },
  6598.     {{"model_origin",        NULL },        ItemParse_model_origin        },
  6599.     {{"model_rotation",        NULL },        ItemParse_model_rotation    },
  6600.     {{"mouseEnter",            NULL },        ItemParse_mouseEnter        },
  6601.     {{"mouseEnterText",        NULL },        ItemParse_mouseEnterText    },
  6602.     {{"mouseExit",            NULL },        ItemParse_mouseExit            },
  6603.     {{"mouseExitText",        NULL },        ItemParse_mouseExitText        },
  6604.     {{"name",                NULL },        ItemParse_name                },
  6605.     {{"notselectable",        NULL },        ItemParse_notselectable        },
  6606.     {{"onFocus",            NULL },        ItemParse_onFocus            },
  6607.     {{"outlinecolor",        NULL },        ItemParse_outlinecolor        },
  6608.     {{"ownerdraw",            NULL },        ItemParse_ownerdraw            },
  6609.     {{"ownerdrawFlag",        NULL },        ItemParse_ownerdrawFlag        },
  6610.     {{"ownerdrawParam",        NULL },        ItemParse_ownerdrawParam    },
  6611.     {{"ownerwidth",            NULL },        ItemParse_ownerwidth        },
  6612.     {{"rect",                NULL },        ItemParse_rect                },
  6613.     {{"showCvar",            NULL },        ItemParse_showCvar            },
  6614.     {{"special",            NULL },        ItemParse_special            },
  6615.     {{"style",                NULL },        ItemParse_style                },
  6616.     {{"text",                NULL },        ItemParse_text                },
  6617.     {{"textalign",            NULL },        ItemParse_textalign            },
  6618.     {{"textalignx",            NULL },        ItemParse_textalignx        },
  6619.     {{"textaligny",            NULL },        ItemParse_textaligny        },
  6620.     {{"textscale",            NULL },        ItemParse_textscale            },
  6621.     {{"textstyle",            NULL },        ItemParse_textstyle            },
  6622.     {{"textfont",            NULL },        ItemParse_textfont            },
  6623.     {{"text2",                NULL },        ItemParse_text2                },
  6624.     {{"text2alignx",        NULL },        ItemParse_text2alignx        },
  6625.     {{"text2aligny",        NULL },        ItemParse_text2aligny        },
  6626.     {{"type",                NULL },        ItemParse_type                },
  6627.     {{"visible",            NULL },        ItemParse_visible            },
  6628.     {{"wrapped",            NULL },        ItemParse_wrapped            },
  6629.     {{"tooltip",            NULL },        ItemParse_tooltip            },
  6630.     {{"hotkey",                NULL },        ItemParse_hotKey            },
  6631.     // Text scroll specific
  6632.     {{"maxLineChars",        NULL },        ItemParse_maxLineChars        },
  6633.     {{"lineHeight",            NULL },        ItemParse_lineHeight        },
  6634.  
  6635.     {{ NULL,                NULL },        NULL                        }
  6636. };
  6637.  
  6638. keywordHash_t *itemParseKeywordHash[KEYWORDHASH_SIZE];
  6639.  
  6640. /*
  6641. ===============
  6642. Item_SetupKeywordHash
  6643. ===============
  6644. */
  6645. void Item_SetupKeywordHash(void) 
  6646. {
  6647.     int i;
  6648.  
  6649.     memset(itemParseKeywordHash, 0, sizeof(itemParseKeywordHash));
  6650.     for (i = 0; itemParseKeywords[i].keyword.name; i++) 
  6651.     {
  6652.         // Initialize the keyword collision list
  6653.         itemParseKeywords[i].keyword.next = NULL;
  6654.  
  6655.         // Add the keyword
  6656.         KeywordHash_Add( itemParseKeywordHash, (keywordHash_t*)&itemParseKeywords[i]);
  6657.     }
  6658. }
  6659.  
  6660. /*
  6661. ===============
  6662. Item_Parse
  6663. ===============
  6664. */
  6665. qboolean Item_Parse(int handle, itemDef_t *item) 
  6666. {
  6667.     pc_token_t    token;
  6668.     itemHash_t*    key;
  6669.  
  6670.     if (!trap_PC_ReadToken(handle, &token))
  6671.         return qfalse;
  6672.     if (*token.string != '{') {
  6673.         return qfalse;
  6674.     }
  6675.     while ( 1 ) {
  6676.         if (!trap_PC_ReadToken(handle, &token)) {
  6677.             PC_SourceError(handle, "end of file inside menu item\n");
  6678.             return qfalse;
  6679.         }
  6680.  
  6681.         if (*token.string == '}') {
  6682.             return qtrue;
  6683.         }
  6684.  
  6685.         key = (itemHash_t*)KeywordHash_Find(itemParseKeywordHash, token.string);
  6686.         if (!key) {
  6687.             PC_SourceError(handle, "unknown menu item keyword %s", token.string);
  6688.             continue;
  6689.         }
  6690.         
  6691.         if ( !key->func(item, handle) ) {
  6692.             PC_SourceError(handle, "couldn't parse menu item keyword %s", token.string);
  6693.             return qfalse;
  6694.         }
  6695.     }
  6696.     return qfalse;     // bk001205 - LCC missing return value
  6697. }
  6698.  
  6699.  
  6700. static void Item_TextScroll_BuildLines ( itemDef_t* item )
  6701. {
  6702.     textScrollDef_t* scrollPtr = (textScrollDef_t*) item->typeData;
  6703.     int                 width;
  6704.     char*             lineStart;
  6705.     char*             lineEnd;
  6706.     float             w;
  6707.     float             cw;
  6708.  
  6709.     scrollPtr->lineCount = 0;
  6710.  
  6711.     if (!item->text || *item->text == '\0' )
  6712.     {
  6713.         return;
  6714.     }
  6715.  
  6716.     scrollPtr->lineCount = 0;
  6717.     width = scrollPtr->maxLineChars;
  6718.  
  6719.     lineStart = (char*)item->text;
  6720.  
  6721.     lineEnd   = lineStart;
  6722.     w          = 0;
  6723.  
  6724.     // Keep going as long as there are more lines
  6725.     while ( scrollPtr->lineCount < MAX_TEXTSCROLL_LINES )
  6726.     {
  6727.         // End of the road
  6728.         if ( *lineEnd == '\0')
  6729.         {
  6730.             if ( lineStart < lineEnd )
  6731.             {
  6732.                 scrollPtr->lines[ scrollPtr->lineCount++ ] = lineStart;
  6733.             }
  6734.  
  6735.             break;
  6736.         }
  6737.  
  6738.         // Force a line end if its a '\n'
  6739.         else if ( *lineEnd == '\n' )
  6740.         {
  6741.             *lineEnd = '\0';
  6742.             scrollPtr->lines[ scrollPtr->lineCount++ ] = lineStart;
  6743.             lineStart = lineEnd + 1;
  6744.             lineEnd   = lineStart;
  6745.             w = 0;
  6746.             continue;
  6747.         }
  6748.  
  6749.         // Get the current character width 
  6750.         cw = DC->getTextWidth ( va("%c", *lineEnd), item->textFont,item->textscale, 0 );
  6751.  
  6752.         // Past the end of the boundary?
  6753.         if ( w + cw > (item->window.rect.w - SCROLLBAR_SIZE - 10) )
  6754.         {
  6755.             // Past the end so backtrack to the word boundary
  6756.             while ( *lineEnd != ' ' && *lineEnd != '\t' && lineEnd > lineStart )
  6757.             {
  6758.                 lineEnd--;
  6759.             }                    
  6760.  
  6761.             *lineEnd = '\0';
  6762.             scrollPtr->lines[ scrollPtr->lineCount++ ] = lineStart;
  6763.  
  6764.             // Skip any whitespaces
  6765.             lineEnd++;
  6766.             while ( (*lineEnd == ' ' || *lineEnd == '\t') && *lineEnd )
  6767.             {
  6768.                 lineEnd++;
  6769.             }
  6770.  
  6771.             lineStart = lineEnd;
  6772.             w = 0;
  6773.         }
  6774.         else
  6775.         {
  6776.             w += cw;
  6777.             lineEnd++;
  6778.         }
  6779.     }
  6780. }
  6781.  
  6782. // Item_InitControls
  6783. // init's special control types
  6784. void Item_InitControls(itemDef_t *item) 
  6785. {
  6786.     if (item == NULL) 
  6787.     {
  6788.         return;
  6789.     }
  6790.  
  6791.     switch ( item->type )
  6792.     {
  6793.         case ITEM_TYPE_LISTBOX:
  6794.         case ITEM_TYPE_COMBOBOX:
  6795.         {
  6796.             listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
  6797.             item->cursorPos = 0;
  6798.             if (listPtr) 
  6799.             {
  6800.                 listPtr->cursorPos = 0;
  6801.                 listPtr->startPos = 0;
  6802.                 listPtr->endPos = 0;
  6803.                 listPtr->cursorPos = 0;
  6804.             }
  6805.  
  6806.             break;
  6807.         }
  6808.     }
  6809. }
  6810.  
  6811. /*
  6812. ===============
  6813. Menu Keyword Parse functions
  6814. ===============
  6815. */
  6816.  
  6817. qboolean MenuParse_name( itemDef_t *item, int handle ) {
  6818.     menuDef_t *menu = (menuDef_t*)item;
  6819.     if (!PC_String_Parse(handle, &menu->window.name)) {
  6820.         return qfalse;
  6821.     }
  6822.     if (Q_stricmp(menu->window.name, "main") == 0) {
  6823.         // default main as having focus
  6824.         //menu->window.flags |= WINDOW_HASFOCUS;
  6825.     }
  6826.     return qtrue;
  6827. }
  6828.  
  6829. qboolean MenuParse_fullscreen( itemDef_t *item, int handle ) {
  6830.     menuDef_t *menu = (menuDef_t*)item;
  6831.     if (!PC_Int_Parse(handle, (int*) &menu->fullScreen)) { // bk001206 - cast qboolean
  6832.         return qfalse;
  6833.     }
  6834.     return qtrue;
  6835. }
  6836.  
  6837. qboolean MenuParse_rect( itemDef_t *item, int handle ) {
  6838.     menuDef_t *menu = (menuDef_t*)item;
  6839.     if (!PC_Rect_Parse(handle, &menu->window.rect)) {
  6840.         return qfalse;
  6841.     }
  6842.     return qtrue;
  6843. }
  6844.  
  6845. /*
  6846. =================
  6847. MenuParse_style
  6848. =================
  6849. */
  6850. qboolean MenuParse_style( itemDef_t *item, int handle) 
  6851. {
  6852.     menuDef_t *menu = (menuDef_t*)item;
  6853.  
  6854.     if (!PC_Int_Parse(handle, &menu->window.style))
  6855.     {
  6856.         Com_Printf(S_COLOR_YELLOW "Unknown menu style value");
  6857.         return qfalse;
  6858.     }
  6859.  
  6860.     return qtrue;
  6861. }
  6862.  
  6863. qboolean MenuParse_visible( itemDef_t *item, int handle ) {
  6864.     int i;
  6865.     menuDef_t *menu = (menuDef_t*)item;
  6866.  
  6867.     if (!PC_Int_Parse(handle, &i)) {
  6868.         return qfalse;
  6869.     }
  6870.     if (i) {
  6871.         menu->window.flags |= WINDOW_VISIBLE;
  6872.     }
  6873.     return qtrue;
  6874. }
  6875.  
  6876. qboolean MenuParse_onOpen( itemDef_t *item, int handle ) {
  6877.     menuDef_t *menu = (menuDef_t*)item;
  6878.     if (!PC_Script_Parse(handle, &menu->onOpen)) {
  6879.         return qfalse;
  6880.     }
  6881.     return qtrue;
  6882. }
  6883.  
  6884. qboolean MenuParse_onClose( itemDef_t *item, int handle ) {
  6885.     menuDef_t *menu = (menuDef_t*)item;
  6886.     if (!PC_Script_Parse(handle, &menu->onClose)) {
  6887.         return qfalse;
  6888.     }
  6889.     return qtrue;
  6890. }
  6891.  
  6892. qboolean MenuParse_onESC( itemDef_t *item, int handle ) {
  6893.     menuDef_t *menu = (menuDef_t*)item;
  6894.     if (!PC_Script_Parse(handle, &menu->onESC)) {
  6895.         return qfalse;
  6896.     }
  6897.     return qtrue;
  6898. }
  6899.  
  6900.  
  6901.  
  6902. qboolean MenuParse_border( itemDef_t *item, int handle ) {
  6903.     menuDef_t *menu = (menuDef_t*)item;
  6904.     if (!PC_Int_Parse(handle, &menu->window.border)) {
  6905.         return qfalse;
  6906.     }
  6907.     return qtrue;
  6908. }
  6909.  
  6910. qboolean MenuParse_borderSize( itemDef_t *item, int handle ) {
  6911.     menuDef_t *menu = (menuDef_t*)item;
  6912.     if (!PC_Float_Parse(handle, &menu->window.borderSize)) {
  6913.         return qfalse;
  6914.     }
  6915.     return qtrue;
  6916. }
  6917.  
  6918. qboolean MenuParse_backcolor( itemDef_t *item, int handle ) {
  6919.     int i;
  6920.     float f;
  6921.     menuDef_t *menu = (menuDef_t*)item;
  6922.  
  6923.     for (i = 0; i < 4; i++) {
  6924.         if (!PC_Float_Parse(handle, &f)) {
  6925.             return qfalse;
  6926.         }
  6927.         menu->window.backColor[i]  = f;
  6928.     }
  6929.     return qtrue;
  6930. }
  6931.  
  6932. /*
  6933. =================
  6934. MenuParse_descAlignment
  6935. =================
  6936. */
  6937. qboolean MenuParse_descAlignment( itemDef_t *item, int handle ) 
  6938. {
  6939.     menuDef_t *menu = (menuDef_t*)item;
  6940.  
  6941.     if (!PC_Int_Parse(handle, &menu->descAlignment)) 
  6942.     {
  6943.         Com_Printf(S_COLOR_YELLOW "Unknown desc alignment value");
  6944.         return qfalse;
  6945.     }
  6946.  
  6947.     return qtrue;
  6948. }
  6949.  
  6950. /*
  6951. =================
  6952. MenuParse_descX
  6953. =================
  6954. */
  6955. qboolean MenuParse_descX( itemDef_t *item, int handle ) 
  6956. {
  6957.     menuDef_t *menu = (menuDef_t*)item;
  6958.  
  6959.     if (!PC_Int_Parse(handle, &menu->descX))
  6960.     {
  6961.         return qfalse;
  6962.     }
  6963.     return qtrue;
  6964. }
  6965.  
  6966. /*
  6967. =================
  6968. MenuParse_descY
  6969. =================
  6970. */
  6971. qboolean MenuParse_descY( itemDef_t *item, int handle ) 
  6972. {
  6973.     menuDef_t *menu = (menuDef_t*)item;
  6974.  
  6975.     if (!PC_Int_Parse(handle, &menu->descY))
  6976.     {
  6977.         return qfalse;
  6978.     }
  6979.     return qtrue;
  6980. }
  6981. /*
  6982. =================
  6983. MenuParse_descColor
  6984. =================
  6985. */
  6986. qboolean MenuParse_descColor( itemDef_t *item, int handle) 
  6987. {
  6988.     int i;
  6989.     float f;
  6990.     menuDef_t *menu = (menuDef_t*)item;
  6991.  
  6992.     for (i = 0; i < 4; i++) 
  6993.     {
  6994.         if (!PC_Float_Parse(handle, &f)) 
  6995.         {
  6996.             return qfalse;
  6997.         }
  6998.         menu->descColor[i]  = f;
  6999.     }
  7000.     return qtrue;
  7001. }
  7002.  
  7003. qboolean MenuParse_forecolor( itemDef_t *item, int handle ) {
  7004.     int i;
  7005.     float f;
  7006.     menuDef_t *menu = (menuDef_t*)item;
  7007.  
  7008.     for (i = 0; i < 4; i++) {
  7009.         if (!PC_Float_Parse(handle, &f)) {
  7010.             return qfalse;
  7011.         }
  7012.         menu->window.foreColor[i]  = f;
  7013.         menu->window.flags |= WINDOW_FORECOLORSET;
  7014.     }
  7015.     return qtrue;
  7016. }
  7017.  
  7018. qboolean MenuParse_bordercolor( itemDef_t *item, int handle ) {
  7019.     int i;
  7020.     float f;
  7021.     menuDef_t *menu = (menuDef_t*)item;
  7022.  
  7023.     for (i = 0; i < 4; i++) {
  7024.         if (!PC_Float_Parse(handle, &f)) {
  7025.             return qfalse;
  7026.         }
  7027.         menu->window.borderColor[i]  = f;
  7028.     }
  7029.     return qtrue;
  7030. }
  7031.  
  7032. qboolean MenuParse_focuscolor( itemDef_t *item, int handle ) {
  7033.     int i;
  7034.     float f;
  7035.     menuDef_t *menu = (menuDef_t*)item;
  7036.  
  7037.     for (i = 0; i < 4; i++) {
  7038.         if (!PC_Float_Parse(handle, &f)) {
  7039.             return qfalse;
  7040.         }
  7041.         menu->focusColor[i]  = f;
  7042.     }
  7043.     return qtrue;
  7044. }
  7045.  
  7046. qboolean MenuParse_disablecolor( itemDef_t *item, int handle ) {
  7047.     int i;
  7048.     float f;
  7049.     menuDef_t *menu = (menuDef_t*)item;
  7050.     for (i = 0; i < 4; i++) {
  7051.         if (!PC_Float_Parse(handle, &f)) {
  7052.             return qfalse;
  7053.         }
  7054.         menu->disableColor[i]  = f;
  7055.     }
  7056.     return qtrue;
  7057. }
  7058.  
  7059.  
  7060. qboolean MenuParse_outlinecolor( itemDef_t *item, int handle ) {
  7061.     menuDef_t *menu = (menuDef_t*)item;
  7062.     if (!PC_Color_Parse(handle, &menu->window.outlineColor)){
  7063.         return qfalse;
  7064.     }
  7065.     return qtrue;
  7066. }
  7067.  
  7068. qboolean MenuParse_background( itemDef_t *item, int handle ) {
  7069.     const char *buff;
  7070.     menuDef_t *menu = (menuDef_t*)item;
  7071.  
  7072.     if (!PC_String_Parse(handle, &buff)) {
  7073.         return qfalse;
  7074.     }
  7075.     menu->window.background = DC->registerShaderNoMip(buff);
  7076.     return qtrue;
  7077. }
  7078.  
  7079. qboolean MenuParse_cinematic( itemDef_t *item, int handle ) {
  7080.     menuDef_t *menu = (menuDef_t*)item;
  7081.  
  7082.     if (!PC_String_Parse(handle, &menu->window.cinematicName)) {
  7083.         return qfalse;
  7084.     }
  7085.     return qtrue;
  7086. }
  7087.  
  7088. qboolean MenuParse_ownerdrawFlag( itemDef_t *item, int handle ) {
  7089.     int i;
  7090.     menuDef_t *menu = (menuDef_t*)item;
  7091.  
  7092.     if (!PC_Int_Parse(handle, &i)) {
  7093.         return qfalse;
  7094.     }
  7095.     menu->window.ownerDrawFlags |= i;
  7096.     return qtrue;
  7097. }
  7098.  
  7099. qboolean MenuParse_ownerdraw( itemDef_t *item, int handle ) {
  7100.     menuDef_t *menu = (menuDef_t*)item;
  7101.  
  7102.     if (!PC_Int_Parse(handle, &menu->window.ownerDraw)) {
  7103.         return qfalse;
  7104.     }
  7105.     return qtrue;
  7106. }
  7107.  
  7108.  
  7109. // decoration
  7110. qboolean MenuParse_popup( itemDef_t *item, int handle ) {
  7111.     menuDef_t *menu = (menuDef_t*)item;
  7112.     menu->window.flags |= WINDOW_POPUP;
  7113.     return qtrue;
  7114. }
  7115.  
  7116.  
  7117. qboolean MenuParse_outOfBounds( itemDef_t *item, int handle ) {
  7118.     menuDef_t *menu = (menuDef_t*)item;
  7119.  
  7120.     menu->window.flags |= WINDOW_OOB_CLICK;
  7121.     return qtrue;
  7122. }
  7123.  
  7124. qboolean MenuParse_soundLoop( itemDef_t *item, int handle ) {
  7125.     menuDef_t *menu = (menuDef_t*)item;
  7126.  
  7127.     if (!PC_String_Parse(handle, &menu->soundName)) {
  7128.         return qfalse;
  7129.     }
  7130.     return qtrue;
  7131. }
  7132.  
  7133. qboolean MenuParse_fadeClamp( itemDef_t *item, int handle ) {
  7134.     menuDef_t *menu = (menuDef_t*)item;
  7135.  
  7136.     if (!PC_Float_Parse(handle, &menu->fadeClamp)) {
  7137.         return qfalse;
  7138.     }
  7139.     return qtrue;
  7140. }
  7141.  
  7142. qboolean MenuParse_fadeAmount( itemDef_t *item, int handle ) {
  7143.     menuDef_t *menu = (menuDef_t*)item;
  7144.  
  7145.     if (!PC_Float_Parse(handle, &menu->fadeAmount)) {
  7146.         return qfalse;
  7147.     }
  7148.     return qtrue;
  7149. }
  7150.  
  7151.  
  7152. qboolean MenuParse_fadeCycle( itemDef_t *item, int handle ) {
  7153.     menuDef_t *menu = (menuDef_t*)item;
  7154.  
  7155.     if (!PC_Int_Parse(handle, &menu->fadeCycle)) {
  7156.         return qfalse;
  7157.     }
  7158.     return qtrue;
  7159. }
  7160.  
  7161. #define VIOLENCE_NAME    "violence_"
  7162.  
  7163.  
  7164. qboolean MenuParse_itemDef( itemDef_t *item, int handle ) 
  7165. {
  7166. #if !(CGAME)
  7167.     char    temp[64];
  7168. #endif
  7169.  
  7170.     menuDef_t *menu = (menuDef_t*)item;
  7171.     if (menu->itemCount < MAX_MENUITEMS) {
  7172.         menu->items[menu->itemCount] = trap_VM_LocalAlloc(sizeof(itemDef_t));
  7173.         Item_Init(menu->items[menu->itemCount]);
  7174.         if (!Item_Parse(handle, menu->items[menu->itemCount])) {
  7175.             return qfalse;
  7176.         }
  7177.  
  7178. #if !(CGAME)
  7179.         if (!ui_allowparental.integer && menu->items[menu->itemCount]->window.name)
  7180.         {
  7181.             strncpy(temp, menu->items[menu->itemCount]->window.name, strlen(VIOLENCE_NAME));
  7182.             temp[strlen(VIOLENCE_NAME)] = 0;
  7183.             if (Q_stricmp(temp, VIOLENCE_NAME) == 0)
  7184.             {
  7185.                 return qtrue;
  7186.             }
  7187.         }
  7188. #endif
  7189.         Item_InitControls(menu->items[menu->itemCount]);
  7190.         menu->items[menu->itemCount++]->parent = menu;
  7191.     }
  7192.     return qtrue;
  7193. }
  7194. /*
  7195. =================
  7196. MenuParse_focuscolor
  7197. =================
  7198. */
  7199. qboolean MenuParse_appearanceIncrement( itemDef_t *item, int handle ) 
  7200. {
  7201.     menuDef_t *menu = (menuDef_t*)item;
  7202.  
  7203.     if (!PC_Float_Parse(handle, &menu->appearanceIncrement))
  7204.     {
  7205.         return qfalse;
  7206.     }
  7207.     return qtrue;
  7208. }
  7209.  
  7210. /*
  7211. =================
  7212. MenuParse_tooltipforecolor
  7213. =================
  7214. */
  7215. qboolean MenuParse_tooltipforecolor ( itemDef_t *item, int handle ) 
  7216. {
  7217.     int i;
  7218.     float f;
  7219.     menuDef_t *menu = (menuDef_t*)item;
  7220.  
  7221.     for (i = 0; i < 4; i++) 
  7222.     {
  7223.         if (!PC_Float_Parse(handle, &f)) 
  7224.         {
  7225.             return qfalse;
  7226.         }
  7227.  
  7228.         menu->tooltipForeColor[i]  = f;
  7229.     }
  7230.  
  7231.     return qtrue;
  7232. }
  7233.  
  7234. /*
  7235. =================
  7236. MenuParse_tooltipbackcolor
  7237. =================
  7238. */
  7239. qboolean MenuParse_tooltipbackcolor ( itemDef_t *item, int handle ) 
  7240. {
  7241.     int i;
  7242.     float f;
  7243.     menuDef_t *menu = (menuDef_t*)item;
  7244.  
  7245.     for (i = 0; i < 4; i++) 
  7246.     {
  7247.         if (!PC_Float_Parse(handle, &f)) 
  7248.         {
  7249.             return qfalse;
  7250.         }
  7251.  
  7252.         menu->tooltipBackColor[i]  = f;
  7253.     }
  7254.  
  7255.     return qtrue;
  7256. }
  7257.  
  7258. /*
  7259. =================
  7260. MenuParse_tooltipscale
  7261. =================
  7262. */
  7263. qboolean MenuParse_tooltipscale ( itemDef_t *item, int handle ) 
  7264. {
  7265.     menuDef_t *menu = (menuDef_t*)item;
  7266.  
  7267.     if (!PC_Float_Parse(handle, &menu->tooltipScale)) 
  7268.     {
  7269.         return qfalse;
  7270.     }
  7271.  
  7272.     return qtrue;
  7273. }
  7274.  
  7275. /*
  7276. =================
  7277. MenuParse_tooltipdelay
  7278. =================
  7279. */
  7280. qboolean MenuParse_tooltipdelay ( itemDef_t *item, int handle ) 
  7281. {
  7282.     menuDef_t *menu = (menuDef_t*)item;
  7283.  
  7284.     if (!PC_Int_Parse(handle, &menu->tooltipDelay)) 
  7285.     {
  7286.         return qfalse;
  7287.     }
  7288.  
  7289.     return qtrue;
  7290. }
  7291.  
  7292. /*
  7293. =================
  7294. MenuParse_tooltipfont
  7295. =================
  7296. */
  7297. qboolean MenuParse_tooltipfont( itemDef_t *item, int handle ) 
  7298. {
  7299.     const char *fontName;
  7300.     menuDef_t  *menu = (menuDef_t*)item;
  7301.  
  7302.     if (!PC_String_Parse(handle, &fontName) )
  7303.     {
  7304.         return qfalse;
  7305.     }
  7306.  
  7307.     menu->tooltipFont = DC->registerFont ( fontName );
  7308.  
  7309.     return qtrue;
  7310. }
  7311.  
  7312.  
  7313. itemHash_t menuParseKeywords[] = 
  7314. {
  7315.     {{"appearanceIncrement"        }, MenuParse_appearanceIncrement    },
  7316.     {{"backcolor"                }, MenuParse_backcolor                },
  7317.     {{"background"                }, MenuParse_background                },
  7318.     {{"border"                    }, MenuParse_border                    },
  7319.     {{"bordercolor"                }, MenuParse_bordercolor            },
  7320.     {{"borderSize"                }, MenuParse_borderSize                },
  7321.     {{"cinematic"                }, MenuParse_cinematic                },
  7322.     {{"descAlignment"            }, MenuParse_descAlignment            },
  7323.     {{"desccolor"                }, MenuParse_descColor                },
  7324.     {{"descX"                    }, MenuParse_descX                    },
  7325.     {{"descY"                    }, MenuParse_descY                    },
  7326.     {{"disablecolor"            }, MenuParse_disablecolor            },
  7327.     {{"fadeAmount"                }, MenuParse_fadeAmount                },
  7328.     {{"fadeClamp"                }, MenuParse_fadeClamp                },
  7329.     {{"fadeCycle"                }, MenuParse_fadeCycle                },
  7330.     {{"focuscolor"                }, MenuParse_focuscolor                },
  7331.     {{"forecolor"                }, MenuParse_forecolor                },
  7332.     {{"fullscreen"                }, MenuParse_fullscreen                },
  7333.     {{"itemDef"                    }, MenuParse_itemDef                },
  7334.     {{"name"                    }, MenuParse_name                    },
  7335.     {{"onClose"                    }, MenuParse_onClose                },
  7336.     {{"onESC"                    }, MenuParse_onESC                    },
  7337.     {{"outOfBoundsClick"        }, MenuParse_outOfBounds            },
  7338.     {{"onOpen"                    }, MenuParse_onOpen                    },
  7339.     {{"outlinecolor"            }, MenuParse_outlinecolor            },
  7340.     {{"ownerdraw"                }, MenuParse_ownerdraw                },
  7341.     {{"ownerdrawFlag"            }, MenuParse_ownerdrawFlag            },
  7342.     {{"popup"                    }, MenuParse_popup                    },
  7343.     {{"rect"                    }, MenuParse_rect                    },
  7344.     {{"soundLoop"                }, MenuParse_soundLoop                },
  7345.     {{"style"                    }, MenuParse_style                    },
  7346.     {{"visible"                    }, MenuParse_visible                },
  7347.     {{"tooltipforecolor"        }, MenuParse_tooltipforecolor        },
  7348.     {{"tooltipbackcolor"        }, MenuParse_tooltipbackcolor        },
  7349.     {{"tooltipscale"            }, MenuParse_tooltipscale            },
  7350.     {{"tooltipdelay"            }, MenuParse_tooltipdelay            },
  7351.     {{"tooltipfont"                }, MenuParse_tooltipfont            },
  7352.     {{ NULL,                    }, NULL                                }
  7353. };
  7354.  
  7355. keywordHash_t *menuParseKeywordHash[KEYWORDHASH_SIZE];
  7356.  
  7357. /*
  7358. ===============
  7359. Menu_SetupKeywordHash
  7360. ===============
  7361. */
  7362. void Menu_SetupKeywordHash(void) 
  7363. {
  7364.     int i;
  7365.  
  7366.     memset(menuParseKeywordHash, 0, sizeof(menuParseKeywordHash));
  7367.     for (i = 0; menuParseKeywords[i].keyword.name; i++) 
  7368.     {
  7369.         // Initialize the collision list
  7370.         menuParseKeywords[i].keyword.next = NULL;
  7371.  
  7372.         // Add the keyword
  7373.         KeywordHash_Add(menuParseKeywordHash, (keywordHash_t*)&menuParseKeywords[i]);
  7374.     }
  7375. }
  7376.  
  7377. /*
  7378. ===============
  7379. Menu_Parse
  7380. ===============
  7381. */
  7382. qboolean Menu_Parse(int handle, menuDef_t *menu) 
  7383. {
  7384.     pc_token_t        token;
  7385.     itemHash_t*        key;
  7386.  
  7387.     if (!trap_PC_ReadToken(handle, &token))
  7388.     {
  7389.         return qfalse;
  7390.     }
  7391.     
  7392.     if (*token.string != '{') 
  7393.     {
  7394.         return qfalse;
  7395.     }
  7396.     
  7397.     while ( 1 ) 
  7398.     {
  7399.         memset(&token, 0, sizeof(pc_token_t));
  7400.  
  7401.         if (!trap_PC_ReadToken(handle, &token)) 
  7402.         {
  7403.             PC_SourceError(handle, "end of file inside menu\n");
  7404.             return qfalse;
  7405.         }
  7406.  
  7407.         if (*token.string == '}') 
  7408.         {
  7409.             return qtrue;
  7410.         }
  7411.  
  7412.         key = (itemHash_t*)KeywordHash_Find(menuParseKeywordHash, token.string);
  7413.         
  7414.         if (!key) 
  7415.         {
  7416.             PC_SourceError(handle, "unknown menu keyword %s", token.string);
  7417.             continue;
  7418.         }
  7419.         
  7420.         if ( !key->func((itemDef_t*)menu, handle) ) 
  7421.         {
  7422.             PC_SourceError(handle, "couldn't parse menu keyword %s", token.string);
  7423.             return qfalse;
  7424.         }
  7425.     }
  7426.  
  7427.     // bk001205 - LCC missing return value
  7428.     return qfalse;     
  7429. }
  7430.  
  7431. /*
  7432. ===============
  7433. Menu_New
  7434. ===============
  7435. */
  7436. void Menu_New(int handle) 
  7437. {
  7438.     menuDef_t *menu = &Menus[menuCount];
  7439.  
  7440.     if (menuCount < MAX_MENUS) 
  7441.     {
  7442.         Menu_Init(menu);
  7443.         
  7444.         if (Menu_Parse(handle, menu)) 
  7445.         {
  7446.             Menu_PostParse(menu);
  7447.             menuCount++;
  7448.         }
  7449.     }
  7450. }
  7451.  
  7452. int Menu_Count() {
  7453.     return menuCount;
  7454. }
  7455.  
  7456. void Menu_PaintAll() {
  7457.     int i;
  7458.     if (captureFunc) {
  7459.         captureFunc(captureData);
  7460.     }
  7461.  
  7462.     // Make sure the color is cleared first
  7463.     DC->setColor ( NULL );
  7464.  
  7465.     for (i = 0; i < Menu_Count(); i++) {
  7466.         Menu_Paint(&Menus[i], qfalse);
  7467.     }
  7468.  
  7469.     if ( DC->tooltipItem )
  7470.     {
  7471.         Tooltip_Paint ( DC->tooltipItem );
  7472.     }
  7473.  
  7474.     if (debugMode) {
  7475.         vec4_t v = {1, 1, 1, 1};
  7476.         DC->drawText(5, 25, DC->Assets.defaultFont, 0.5f, v, va("fps: %f", DC->FPS), 0, 0 );
  7477.         DC->drawText(5, 45, DC->Assets.defaultFont, 0.5f, v, va("x: %d  y:%d", DC->cursorx,DC->cursory), 0, 0 );
  7478.     }
  7479. }
  7480.  
  7481. void Menu_Reset() {
  7482.     menuCount = 0;
  7483. }
  7484.  
  7485. displayContextDef_t *Display_GetContext() {
  7486.     return DC;
  7487. }
  7488.  
  7489. #ifndef MISSIONPACK // bk001206
  7490. static float captureX;
  7491. static float captureY;
  7492. #endif
  7493.  
  7494. void *Display_CaptureItem(int x, int y) {
  7495.     int i;
  7496.  
  7497.     for (i = 0; i < menuCount; i++) {
  7498.         // turn off focus each item
  7499.         // menu->items[i].window.flags &= ~WINDOW_HASFOCUS;
  7500.         if (Rect_ContainsPoint(&Menus[i].window.rect, x, y)) {
  7501.             return &Menus[i];
  7502.         }
  7503.     }
  7504.     return NULL;
  7505. }
  7506.  
  7507.  
  7508. // FIXME: 
  7509. qboolean Display_MouseMove(void *p, int x, int y) {
  7510.     int i;
  7511.     menuDef_t *menu = p;
  7512.  
  7513.     if (menu == NULL) {
  7514.     menu = Menu_GetFocused();
  7515.         if (menu) {
  7516.             if (menu->window.flags & WINDOW_POPUP) {
  7517.                 Menu_HandleMouseMove(menu, x, y);
  7518.                 return qtrue;
  7519.             }
  7520.         }
  7521.         for (i = 0; i < menuCount; i++) {
  7522.             Menu_HandleMouseMove(&Menus[i], x, y);
  7523.         }
  7524.     } else {
  7525.         menu->window.rect.x += x;
  7526.         menu->window.rect.y += y;
  7527.         Menu_UpdatePosition(menu);
  7528.     }
  7529.      return qtrue;
  7530.  
  7531. }
  7532.  
  7533. int Display_CursorType(int x, int y) {
  7534.     int i;
  7535.     for (i = 0; i < menuCount; i++) {
  7536.         rectDef_t r2;
  7537.         r2.x = Menus[i].window.rect.x - 3;
  7538.         r2.y = Menus[i].window.rect.y - 3;
  7539.         r2.w = r2.h = 7;
  7540.         if (Rect_ContainsPoint(&r2, x, y)) {
  7541.             return CURSOR_SIZER;
  7542.         }
  7543.     }
  7544.     return CURSOR_ARROW;
  7545. }
  7546.  
  7547.  
  7548. void Display_HandleKey(int key, qboolean down, int x, int y) {
  7549.     menuDef_t *menu = Display_CaptureItem(x, y);
  7550.     if (menu == NULL) {  
  7551.         menu = Menu_GetFocused();
  7552.     }
  7553.     if (menu) 
  7554.     {
  7555.         Menu_HandleKey(menu, key, down );
  7556.     }
  7557. }
  7558.  
  7559. static void Window_CacheContents(windowDef_t *window) {
  7560.     if (window) {
  7561.         if (window->cinematicName) {
  7562.             int cin = DC->playCinematic(window->cinematicName, 0, 0, 0, 0);
  7563.             DC->stopCinematic(cin);
  7564.         }
  7565.     }
  7566. }
  7567.  
  7568.  
  7569. static void Item_CacheContents(itemDef_t *item) {
  7570.     if (item) {
  7571.         Window_CacheContents(&item->window);
  7572.     }
  7573.  
  7574. }
  7575.  
  7576. static void Menu_CacheContents(menuDef_t *menu) {
  7577.     if (menu) {
  7578.         int i;
  7579.         Window_CacheContents(&menu->window);
  7580.         for (i = 0; i < menu->itemCount; i++) {
  7581.             Item_CacheContents(menu->items[i]);
  7582.         }
  7583.  
  7584.         if (menu->soundName && *menu->soundName) {
  7585.             DC->registerSound(menu->soundName);
  7586.         }
  7587.     }
  7588.  
  7589. }
  7590.  
  7591. void Display_CacheAll() {
  7592.     int i;
  7593.     for (i = 0; i < menuCount; i++) {
  7594.         Menu_CacheContents(&Menus[i]);
  7595.     }
  7596. }
  7597.  
  7598.  
  7599. static qboolean Menu_OverActiveItem(menuDef_t *menu, float x, float y) {
  7600.      if (menu && menu->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED)) {
  7601.         if (Rect_ContainsPoint(&menu->window.rect, x, y)) {
  7602.             int i;
  7603.             for (i = 0; i < menu->itemCount; i++) {
  7604.                 // turn off focus each item
  7605.                 // menu->items[i].window.flags &= ~WINDOW_HASFOCUS;
  7606.  
  7607.                 if (!(menu->items[i]->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) {
  7608.                     continue;
  7609.                 }
  7610.  
  7611.                 if (menu->items[i]->window.flags & WINDOW_DECORATION) {
  7612.                     continue;
  7613.                 }
  7614.  
  7615.                 if (Rect_ContainsPoint(&menu->items[i]->window.rect, x, y)) {
  7616.                     itemDef_t *overItem = menu->items[i];
  7617.                     if (overItem->type == ITEM_TYPE_TEXT && overItem->text) {
  7618.                         if (Rect_ContainsPoint(Item_CorrectedTextRect(overItem), x, y)) {
  7619.                             return qtrue;
  7620.                         } else {
  7621.                             continue;
  7622.                         }
  7623.                     } else {
  7624.                         return qtrue;
  7625.                     }
  7626.                 }
  7627.             }
  7628.  
  7629.         }
  7630.     }
  7631.     return qfalse;
  7632. }
  7633.  
  7634. void Tooltip_Paint ( itemDef_t *item )
  7635. {
  7636.     float        w;
  7637.     float        h;
  7638.     float        x;
  7639.     float        y;
  7640.     menuDef_t    *menu;
  7641.  
  7642.     x = DC->tooltipx;
  7643.     y = DC->tooltipy;
  7644.  
  7645.     // If the item doesnt have a tooltip then dont render one
  7646.     if ( NULL == item->tooltip )
  7647.     {
  7648.         return;
  7649.     }
  7650.  
  7651.     menu = item->parent;
  7652.  
  7653.     // Only render the tooltip if the cursor has been stopped for at 
  7654.     // at least tooltipDelay time
  7655.     if ( DC->realTime - DC->tooltiptime < menu->tooltipDelay )
  7656.         return;
  7657.  
  7658.     // TODO: Determine the width and height of the text and adjust the
  7659.     //       orientation of the tooltip to ensure it fits on the screen
  7660.  
  7661.     w = DC->getTextWidth ( item->tooltip, menu->tooltipFont, menu->tooltipScale, 0 );
  7662.     h = DC->getTextHeight ( item->tooltip, menu->tooltipFont, menu->tooltipScale, 0 );
  7663.  
  7664.     // Draw the background and border for the tooltip
  7665.     DC->fillRect( x, y, w + 6, h + 6, menu->tooltipBackColor );
  7666.     DC->drawRect( x, y, w + 6, h + 6, 1, menu->tooltipForeColor );
  7667.  
  7668.     // Draw the tooltip text
  7669.     DC->drawText( x + 3, y + 2, menu->tooltipFont, menu->tooltipScale, menu->tooltipForeColor, item->tooltip, 0, 0 );
  7670. }
  7671.